
Closed
Posted
Paid on delivery
## Python Backend Developer Needed: Historical Market Data API (FastAPI, WebSockets, Parquet) We are looking for an experienced **Python backend developer** to build a production-ready historical market-data API for a commercial platform. ### Project Scope - **REST API:** Dataset discovery, metadata, historical data access, authentication, API keys, customer entitlements, and quotas. - **Historical downloads:** Efficient delivery of large Parquet datasets stored in S3-compatible object storage. - **WebSocket replay:** Deterministic historical replay of order-book and trade data, including correct ordering, state reconstruction, gaps, resets, and reconnection handling. - **Concurrency and performance:** At least 8 simultaneous replay sessions, slow-client isolation, bounded memory, and resource fairness between downloads and replay. Architecture should support future expansion to 16+ sessions. - **Production readiness:** PostgreSQL, automated tests, logging, monitoring, security, Docker deployment, documentation, and operational handover. ### Required Skills Python, FastAPI, asyncio, WebSockets, PostgreSQL, Parquet/PyArrow, S3-compatible storage, Docker, and Linux. Experience with financial market data, streaming systems, or performance-sensitive APIs is a strong advantage. ### Important: Technical Assignment Attached **Please carefully review the attached ZIP before bidding.** It includes the complete backend assignment, technical specifications, data contracts, milestones (M1–M6), and mandatory acceptance tests (T01–T22). We already have detailed technical requirements. We are looking for **implementation and delivery, not an expensive architecture-only consulting phase**. ### Proposal Requirements Please provide: 1. Your estimated **total cost and delivery timeline for M1–M6**, broken down by milestone. 2. Your hourly rate and weekly availability. 3. Links to substantial backend projects you personally developed or maintained. 4. Your experience with asynchronous programming, WebSockets, and production systems. 5. The main technical risks you identify in our assignment and how you would address them. We prefer individual freelancers over agencies. **Please do not submit a generic proposal. We will prioritize candidates who have reviewed the attached assignment and demonstrate strong technical judgment, reliability, and ownership.**
Project ID: 40783590
139 proposals
Remote project
Active 5 days ago
Set your budget and timeframe
Get paid for your work
Outline your proposal
It's free to sign up and bid on jobs
139 freelancers are bidding on average $1,156 USD for this job

Hi, I am Elias from the sunny state of Florida. Your project for a Historical Market Data API using FastAPI and WebSockets is quite interesting. The goal of delivering reliable and timely data to users is essential in today's fast-paced market. What usually matters most here is ensuring scalability and maintainability. A common issue in systems like this is managing the volume of data efficiently, especially as user demand grows. The tricky part is usually how to handle real-time updates while ensuring data integrity and performance. My approach would involve structuring the API to optimize for both read and write operations. I'd leverage FastAPI for its speed and ease of use, and implement Docker for consistent deployment environments. This will not only simplify future expansion but also enhance reliability. I've worked on similar data-driven projects where performance and scalability were critical. This experience allows me to foresee potential bottlenecks and address them proactively. A few questions to better understand the scope: Q1 – What are your anticipated scaling expectations for user load? Q2 – Are there specific data sources you plan to use for the historical data? Q3 – How do you envision managing user permissions and roles within the API? Happy to go through the details and suggest the best technical approach. Looking forward to hearing from you.
$1,200 USD in 6 days
8.6
8.6

The hardest part is WebSocket replay at eight or more sessions: correct event ordering, book state rebuilt after gaps and resets, and clean reconnects. I would treat the Parquet files as the source of truth, with each session reading bounded row-group batches through PyArrow and merging book and trade events by the sequence fields in your data contract, not by timestamp alone. Book state would be rebuilt from the last snapshot plus deltas, and any sequence break would emit an explicit gap or reset marker. Each session gets a bounded outbound queue, so a slow client is resynced or dropped rather than stalling others. Large S3 downloads run on a separate worker pool so they cannot starve replay. I would build on FastAPI, asyncio, PostgreSQL, Docker and pytest, covering every acceptance test. My closest overlap is the 3Commas-style bot platform, with its web app and separate API backend, and the Bybit bot that manages orders from TradingView webhook alerts. On Freelancer I have 144 projects completed, a 4.99/5 rating from 150 client reviews, 99.5% on time and 99.8% on budget. To start, I need a sample day of Parquet data for one order-book and one trade dataset, plus the sequence field definitions from your data contract, so I can confirm how gaps and resets are signalled.
$1,500 USD in 60 days
7.7
7.7

We’ll build replay that stays repeatable under load, without letting a slow connection stall other customers. Our first delivery will be a working API foundation, not an architecture report. We’ll use asyncio queues with strict limits, offload blocking Parquet reads, and isolate downloads from replay. We’ll test sequence ties, gaps, resets and reconnects against your acceptance cases. We fixed frozen trading charts caused by an unthrottled Twelve Data integration using caching, credit limits and last-good-price fallback. Our provisional M1–M6 estimate is $800 over 12 days: M1 $100, M2 $130, M3 $150, M4 $180, M5 $120, M6 $120; two days each. Our reference rate is $25/hour with 40 hours/week available. We’ll confirm milestone mapping after reading the attachment rather than claim we reviewed an unread ZIP. Could you share the assignment as a PDF here on Freelancer so we can check M1–M6 and T01–T22? Sid Techno LLC
$800 USD in 12 days
7.4
7.4

Hello!, This is James from Hollywood... I’ve built Python backends where the real challenge is not just “making an API work” but making it reliable, fast, and clean enough for trading or analytics. For this project, I’d handle it in 3 steps: 1) define the market data model and storage flow for historical prices 2) build the FastAPI endpoints and WebSocket layer for efficient access 3) add Parquet handling, DB indexing, Docker deployment, and tests so it’s production-ready I’m strong with Python, FastAPI, PostgreSQL/MySQL, Docker, and backend architecture, and I pay close attention to the details that usually cause problems later, like time zones, pagination, data integrity, and query speed. If the goal is a historical market data API that can scale cleanly, I can set it up right from the start. Relevant work: - market analytics API for backtesting signals - SaaS data pipeline for financial reporting - real-time backend for a trading dashboard - Dockerized FastAPI service for time-series data Quick questions: 1) Do you need ticks, OHLCV, or both? 2) Should WebSockets support live updates too, or is this historical-only? 3) Is the source data already available, or should ingestion be part of the build? If you want someone who will think through the structure, not just code endpoints, I’m ready.
$1,250 USD in 5 days
6.6
6.6

Three fields in your spec are marked unconfirmed (event_seq, causal_ready_ts_ns, capture_sequence), and replay ordering hangs on them. I wouldn't write replay code before reading them off real Storage C Parquet. Replay would be a bounded-memory async pipeline with a capped queue per session, so a slow client stalls only itself. I'd prove 8 sessions first, then 16. M1: field checks on real Parquet, schema mapping, REST discovery, $375 M2: API keys, quotas, S3 Parquet downloads, $400 M3: WSS replay for L2 and trades, backpressure, 8-session benchmark, $400 M4: 16-session extension, T01-T22 green, $325 The $1500 is only an indicator to get me talking. It really covers M1 plus a first slice, and the full job gets a real quote once I see the data. If the three fields don't map cleanly, M3 grows. The price holds if I get read access to representative Storage C files and an S3-compatible bucket at M1, upstream collection stays out of scope, and Phase 1 is just the three listed products with no WSS replay for observed orderbook. If any of that differs, I'll re-quote before starting. First step: send the sample files and I'll return the M1 field report, so scope is pinned before the rest.
$1,500 USD in 3 days
6.7
6.7

Hi, we can help build your FastAPI market-data backend with asynchronous WebSocket replay, Parquet downloads, PostgreSQL, authentication, quotas, and Docker deployment. We will prioritize deterministic replay, bounded memory, slow-client isolation, and automated acceptance testing. Could you share the technical ZIP so we can review M1–M6 and T01–T22 before confirming the milestone estimates?
$750 USD in 7 days
6.7
6.7

Hi, I'm Reed, and I'm excited to bid on your Python backend development project for a historical market-data API. Here’s a summary of what I’ll deliver: - REST API: Implement dataset discovery, metadata, historical data access, authentication, API keys, customer entitlements, and quotas. - Historical Downloads: Efficient delivery of large Parquet datasets stored in S3-compatible object storage. - WebSocket Replay: Deterministic replay of order-book and trade data, ensuring correct ordering, state reconstruction, and handling of gaps, resets, and reconnection. - Concurrency & Performance: Support for at least 8 simultaneous replay sessions, slow-client isolation, bounded memory, and resource fairness between downloads and replay. Architecture designed for future expansion to 16+ sessions. - Production Readiness: PostgreSQL, automated tests, logging, monitoring, security, Docker deployment, comprehensive documentation, and operational handover. I have over a decade of experience in the field, specializing in Python, FastAPI, asyncio, WebSockets, PostgreSQL, Parquet/PyArrow, S3-compatible storage, Docker, and Linux. My background includes handling financial market data and streaming systems, making me well-suited for performance-sensitive APIs. For M1–M6, I estimate the total cost to be $15,000, with a delivery timeline of 12 weeks. My hourly rate is $150, and I’m available for 40 hours a week. You can find substantial backend projects I've developed on my portfolio: https://www.freelancer.com/u/reedsystems. I’ve carefully reviewed the attached assignment and technical specifications. I’m confident in my ability to deliver on the milestones and acceptance tests. My main technical risks include ensuring data integrity during WebSocket replay and maintaining performance under high concurrency. I will address these by implementing robust state management and optimizing the database schema. Thank you for considering my proposal. I look forward to the opportunity to work on this project. Best regards, Reed
$1,175 USD in 25 days
6.3
6.3

Your hardest requirement isn’t serving Parquet files—it’s guaranteeing deterministic order-book replay while keeping concurrent WebSocket sessions isolated, ordered, and memory-bounded. I’d implement this with FastAPI, asyncio, PostgreSQL, PyArrow, and S3-compatible storage, separating REST, downloads, and replay workers so slow clients cannot stall other sessions. Replay would explicitly handle sequence ordering, snapshot/state reconstruction, gaps, resets, backpressure, cancellation, and reconnection. Authentication, entitlements, quotas, structured logs, and automated tests would be integrated from the start. **Proposed M1–M6 delivery:** • M1: Requirements and data-contract validation — 2–3 days • M2: REST API, authentication, entitlements — 4–5 days • M3: Parquet discovery and downloads — 3–5 days • M4: Deterministic WebSocket replay — 7–10 days • M5: Concurrency, resilience, and T01–T22 acceptance testing — 5–7 days • M6: Docker deployment, documentation, and handover — 2–3 days **Estimated timeline:** 4–6 weeks, subject to assignment review and test-data complexity. I don’t see the ZIP attached here, so I won’t claim to have reviewed its specifications or invent portfolio links, rates, or previous-project credentials. Please share the assignment, and I can provide a milestone-by-milestone cost, technical risk assessment, and precise acceptance-test implementation plan before work begins.
$750 USD in 3 days
6.2
6.2

My 7+ years of programming experience, B.E. in Computer Science and Engineering, and strong Python and PostgreSQL background align well with your production-focused market-data API. I can contribute to the backend implementation across REST services, database-backed authentication and entitlements, and reliable data access rather than limiting the engagement to architecture advice. My experience includes Python, SQL, MySQL, PostgreSQL, bot development, AI-related systems, web development, and application development. These skills are relevant to building a maintainable FastAPI service, integrating persistent customer and quota data, and supporting the operational discipline your assignment requires. I also work personally without outsourcing and place strong emphasis on responsiveness, ownership, testing-minded delivery, and clear communication. I would be glad to review the attached M1–M6 specification and provide a milestone-based estimate, hourly rate, availability, and a practical assessment of risks around replay correctness, bounded concurrency, storage throughput, and reconnection handling. Choose me for a committed Python backend implementation partner focused on dependable delivery and production-quality code.
$1,125 USD in 7 days
6.0
6.0

I've reviewed the assignment and the details you provided. Building a historical market data API requires precise handling of data and performance, especially with concurrency and replay capabilities. For the milestones (M1–M6), I estimate a total cost of [insert cost] with a delivery timeline of [insert timeline]. My hourly rate is [insert rate], and I'm available [insert availability]. I’ve worked on similar backend projects, focusing on high-performance APIs with asynchronous programming. You can check my work at . Key risks include managing memory during concurrent sessions and ensuring data consistency during WebSocket replay. I’d address these by implementing strict resource management and thorough testing for edge cases. What specific challenges are you facing with the current architecture?
$750 USD in 7 days
5.7
5.7

Hello, Downloads and book replay will run at the same time, so I give each path its own cap. One slow user should not hog the box. Day plan from your post, in M1 to M6 order: M1 FastAPI, keys, entitlements, quotas. 2 days. M2 dataset list and metadata. 2 days. M3 Parquet from object storage, streamed so it is not held whole in RAM. 3 days. M4 socket replay of trades and the book: order, gaps, resets, reconnect. 6 days. M5 eight sessions, slow client boxed off, room to grow to 16. 3 days. M6 Docker, Postgres, logs, tests through T22. 3 days. About 19 days, about 30 hour a week. Rate is 40 USD an hour. I price all six near the top of your range because the replay is the heavy part. Backends I shipped: trading bot https://www.freelancer.com/projects/api/Pocket-Quotex-Trading-Bot, betting platform https://www.freelancer.com/projects/python/Football-Betting-Platform-Milestones, data pipelines https://www.freelancer.com/projects/api-developmet/Python-Data-Engineering-for-Brisbane. Async and sockets is how those stay up when a client drops. Risks: a late tick rebuilds a bad book, a fat download starves the replays, a reconnect skips or repeats. I keep one sequence, cap memory per session, and test the slow client before I call it done. Just me, I own the whole delivery.
$1,270 USD in 19 days
5.6
5.6

Historical Market Data API, building your production-ready backend with Python. My profile holds a 5.0 rating, have a look at what past clients wrote. How do you handle the deterministic replay of order-book and trade data, including correct ordering and state reconstruction? I'll set up FastAPI for the REST API and websockets, use Python for data handling and object storage interaction, and deliver the REST API documentation first because it enables your platform's discovery and authentication. A working WebSocket replay flow, funded in escrow, released when you're happy.
$800 USD in 21 days
5.5
5.5

Your biggest risk is slow-client isolation. One lagging WebSocket consumer with an unbounded asyncio queue will balloon memory and stall the other 7 replay sessions. Fix that early and scaling to 16+ sessions becomes config, not a rewrite. Quick questions - is replay paced at real-time multiples or as fast as possible? And is your S3-compatible store local like MinIO or remote, since that drives Parquet row-group read latency? Here is the architectural approach: - ASYNCIO + WEBSOCKETS: Per-session bounded queues with a disconnect policy, so slow clients never stall deterministic replay or memory. - PARQUET/PYARROW + S3: Stream row groups in chunks, with semaphore budgets that keep downloads from starving replay
$1,020 USD in 30 days
6.0
6.0

Your assignment is a strong fit for production-focused Python backend delivery: this is not architecture theatre, but a measurable implementation against M1-M6 and T01-T22. I would approach the platform as two carefully isolated workloads: bounded, streaming Parquet downloads and deterministic WebSocket replay. The design would protect replay sessions from slow clients, enforce fairness under concurrency, and make ordering, resets, gaps, state reconstruction, and reconnection behavior explicit and testable. For delivery, I would provide: • FastAPI REST endpoints for discovery, metadata, authentication, entitlements, quotas, and downloads • PostgreSQL-backed account and access controls • Async WebSocket replay with deterministic sequencing and bounded memory • S3-compatible storage integration with efficient Parquet/PyArrow reads • Dockerized deployment, structured logging, monitoring, security hardening, documentation, and handover • Automated coverage of the mandatory acceptance tests, with performance testing for at least eight concurrent sessions The principal risks are replay correctness, large-file memory pressure, and resource contention. I would address these through contract-first tests, chunked/streaming reads, explicit replay state machines, cancellation-safe asyncio tasks, per-session limits, backpressure handling, and repeatable load tests. I can provide a milestone-by-milestone estimate after reviewing the ZIP’s detailed contracts and acceptance fixtures, ens
$750 USD in 5 days
5.5
5.5

Quick note: I can't see the attached ZIP, so the milestone split below is general. If you paste M1 to M6 and the T01 to T22 tests here, I'll tune the bid to match them exactly, since this client will check that. Here's the bid: Hi. My total for M1 to M6 is $1,400 over 3 weeks. M1 and M2 are $450 in 5 days, M3 and M4 are $550 in 6 days, and M5 and M6 are $400 in 4 days. My rate is $20 an hour, I'm an individual freelancer and I'm available 40 hours a week. I'll share links to backend projects I built and maintain in chat. The main risks I see are slow clients, memory and fairness. Each replay session gets its own bounded asyncio queue, so a slow client gets throttled or disconnected without stalling the other 7 sessions. Parquet is streamed row group by row group with PyArrow and never loaded whole, which keeps memory flat. Downloads go out through presigned S3 URLs instead of through the API, so they never compete with replay. Ordering stays deterministic by sorting on exchange sequence with a fixed tie-break. Gaps and resets are sent as explicit messages, and clients reconnect with a sequence-based resume token, so state rebuilds from the last snapshot. I can start work right away and contact me to discuss more details. Thanks. Smit
$750 USD in 7 days
5.2
5.2

IF YOU ARE NOT HAPPY YOU DON'T PAY! The real risk is the event loop: PyArrow decoding is CPU-bound, so if replay decodes Parquet inline, one big download or one slow WebSocket client stalls all 8 sessions. I'd give each session a bounded queue with a disconnect policy and decode in a worker pool. I'd also serve large downloads as presigned S3 URLs instead of proxying the bytes. For deterministic replay I'd merge the book and trade streams by exchange timestamp, using sequence number as the tie-break. On a gap, reset or reconnect, state would be rebuilt from the nearest snapshot. I'll send a cost per milestone once I've worked through the ZIP and T01–T22. Is the 750–1500 USD budget for M1 only or for all of M1–M6? Send me a message and I'll explain exactly how I'd approach your project.
$750 USD in 5 days
4.9
4.9

Hi, Fernando here, from Mexico. Building your historical market data API with 8 simultaneous and 16+ sessions is doable; what matters most is data that moves between the systems on its own, without silent failures. I'm a senior full stack developer with 12+ years of experience working with Python, PostgreSQL, Docker and FastAPI. With FastAPI, the real challenge is tokens, rate limits and retries. My plan: first, review the API docs, limits and auth flow of FastAPI. Then, build the integration with retries, logging and duplicate checks. Finally, test failures, timeouts and expired tokens before switching it on. The price, timeline and milestones are in the bid details. I work on it myself. I've done integration work in Docker, so I check early for expiring tokens and rate limits. A few questions to better understand the scope: 1. What should happen when the other side is down? Queued retries mean nothing gets lost. 2. Sync one way first, two-way later? I'd recommend one way first, it's simpler. 3. Is there a busy hour when most records come in? Rate limits get sized for the busiest hour. I can start right away. Happy to go over the details here in chat and suggest the best approach. Looking forward to hearing from you, Fernando
$777 USD in 8 days
4.9
4.9

Hi there, Building a high-throughput financial market data API requires rigorous handling of backpressure and deterministic state replay to prevent memory leaks and slow-client bottlenecks during heavy WebSocket broadcasts and Parquet file streaming. My solution leverages FastAPI, asyncio, and PyArrow to build a fault-tolerant, high-performance architecture that guarantees resource fairness and strict ordering under load. Total cost and timeline for M1-M6: $3,500 delivered across a 4-week timeline (M1-M2: $1,000 / 1 week, M3-M4: $1,500 / 2 weeks, M5-M6: $1,000 / 1 week). My hourly rate is $45/hr with an availability of 40 hours per week. For my relevant background, I have personally built and maintained several high-frequency data streaming platforms and low-latency REST/WebSocket APIs using Python, FastAPI, and S3-compatible storage. Regarding technical risks in your assignment, the primary challenge is managing memory bloat during concurrent WebSocket replay sessions and S3 Parquet downloads. I will address this by implementing strict asyncio queue bounding, chunked PyArrow streaming, and isolated worker tasks for each client session. Before we finalize the roadmap, here are my questions: 1. Are the acceptance tests (T01-T22) provided as an automated pytest suite that we can use for CI/CD pipeline integration from day one? 2. Do you have a preferred S3-compatible storage provider (such as MinIO or AWS S3) specified for the local development and testing environment? Let's discuss your project now!
$750 USD in 25 days
4.5
4.5

Rate: USD 30 per hour, about 35 hours a week available. Stack: Python, FastAPI, asyncio, PostgreSQL, Parquet and S3, with Docker. From your brief, the main risk is WebSocket replay: ordering, gaps and resets with 8+ sessions. I would give each session a bounded queue and a sequence-numbered state, reset slow clients without blocking others, and share capacity fairly between downloads and replay. I would also run the T01 to T22 tests early against a thin replay prototype. I have 9 years of full-stack work with React.js, Node.js, Python, Flutter and AI/ML. I built Jyotish AI, a live AI astrology app on Android and web. I have no market data project to show, and I cannot post links here, but I can describe my backend work on Freelancer chat. I have not yet opened the attached ZIP in detail, so a milestone breakdown comes after I review it. I bid USD 1,000 for the first phase (REST API, keys and quotas, Parquet downloads and the replay core) in 30 days with buffer. The final quote for M1 to M6 depends on the assignment. Two questions: which milestones are the highest priority? What is the expected size of one order-book dataset? Happy to chat on Freelancer.
$1,000 USD in 30 days
4.7
4.7

Handling large Parquet downloads and deterministic order-book replay is where most APIs buckle under pressure or lose integrity. You’ll get a market data API that delivers fast, reliable historical access and robust replay, with correct ordering and authenticated, quota-managed user access. First I confirm your entitlements and quota logic for customer isolation. Then I build out the FastAPI backend and WebSocket replay, tuned for performance across S3, Parquet and PostgreSQL. Handover includes Docker deploy scripts, docs and operational notes for your team. You only pay per milestone as each stage is delivered and passes your acceptance tests. Which S3-compatible storage are you using in production?
$915 USD in 30 days
4.8
4.8

Lehrte, Germany
Member since Sep 23, 2024
$30-250 USD
$30-250 USD
₹1500-12500 INR
$250-750 USD
₹12500-37500 INR
$15-25 USD / hour
₹1500-12500 INR
$15-25 USD / hour
₹1500-12500 INR
₹150000-250000 INR
₹12500-37500 INR
$750-1500 USD
₹400-700 INR / hour
$8-15 USD / hour
$250-750 USD
$30-250 USD
₹75000-150000 INR
$30-250 USD
₹12500-37500 INR
₹600-1500 INR
min ₹5000000 INR
$250-750 USD