
Closed
Posted
Paid on delivery
I want to turn my current trading rules into software that can be tested against historical stock and ETF data before anything goes live. The first and only milestone for now is a reliable back-testing engine: feed in price history, run the logic, and give me clear performance metrics—equity curve, drawdown, Sharpe, win rate, and a full trade log. My rules (mainly price action with a few technical indicators) will be supplied once we start, so please structure the code so entries, exits, and position sizing can be tweaked from a single config file. I am comfortable with Python, C#, or JavaScript—use whichever stack lets you work fastest, as long as I can reproduce the results on a Windows 10 machine. Deliverables • Well-commented source code • Setup instructions and dependency list • Sample report (CSV or HTML) showing metrics and trade list Acceptance criteria • Results line up with a hand-checked sample I’ll provide • Runs entirely offline on my PC • Parameters editable without touching core code If you have a past stock or ETF back-testing project, a brief example or GitHub link will help me choose quickly. Let’s build something solid together.
Project ID: 40795567
95 proposals
Remote project
Active 21 hours ago
Set your budget and timeframe
Get paid for your work
Outline your proposal
It's free to sign up and bid on jobs
95 freelancers are bidding on average ₹19,668 INR for this job

Look-ahead bias sinks most backtesters: signals on a bar's close filled at that same close. Ours fills next bar, so hand-checks match. Day 1: working engine with a placeholder rule set, config file and a sample CSV/HTML report for you to verify against your hand-checked trades. Day 3: final commented code, setup notes, tested on Windows 10, in Python. 1. Daily bars or intraday? 2. One ticker at a time, or a basket sharing one capital pool? Your rules can drop in the moment you send them; ready to start today in chat.
₹18,050 INR in 3 days
7.9
7.9

The biggest risk in a stock and ETF backtester isn't the math. It's look-ahead bias and unadjusted split or dividend data. Either one inflates your Sharpe and equity curve, so results won't match your hand-checked sample or live trading. Quick questions - will your rules fill on the signal bar's close or the next bar's open? And where's your price history coming from, and does it include adjusted prices? Here is the architectural approach: - BACKTESTING: An event-driven Python engine processes bars in order, runs f
₹22,500 INR in 7 days
7.3
7.3

Hello, You need a backtester you can trust before any real money moves. I would build it in Python so it stays easy to read, runs fully offline on Windows 10, and is quick to tweak when your rules change. The core idea is simple. Price history goes in, your logic runs bar by bar, and you get a clear report out: equity curve, drawdown, Sharpe, win rate, and a full trade log in CSV or HTML. Entries, exits, and position sizing live in one config file, so you adjust knobs without digging through the engine. I would start with a small hand-checked sample of your rules, lock the results against your numbers, then expand to stocks and ETFs. That way we catch mismatches early instead of debugging a black box later. You get well-commented source, setup steps, a dependency list, and a sample report you can open on your PC. If that sounds like the pace you want, I am ready to kick off as soon as your rules and the sample checks are ready.
₹28,000 INR in 7 days
6.0
6.0

Since 2015, I have worked as a Senior Software Engineer building reliable software with Python, JavaScript, SQL, and data-focused development—an excellent foundation for an offline stock and ETF backtesting engine. I can turn your supplied price-action and indicator rules into maintainable code while keeping entries, exits, and position sizing editable through configuration rather than buried in the core logic. My Python and Data Analysis skills are directly suited to processing historical price data, calculating equity curves, drawdown, Sharpe ratio, win rate, and detailed trade logs. I will also provide well-commented source code, a dependency list, Windows 10 setup instructions, and a CSV or HTML sample report. My broader software engineering experience supports a structured implementation that can be checked against your hand-verified sample and reproduced entirely offline. I would be glad to build a solid, configurable backtesting foundation for your strategy and deliver code you can extend confidently.
₹34,000 INR in 15 days
6.0
6.0

Dear Mahend, I am very interested in developing your Stock & ETF Strategy Backtester and confident in delivering a robust, precise back-testing engine tailored to your requirements. Leveraging extensive experience in Python, C#, and JavaScript—along with strong competence in algorithmic trading, data analysis, and software architecture—I will build a flexible solution that processes historical price data, executes your trading logic, and outputs detailed performance metrics including equity curves, drawdown statistics, Sharpe ratios, win rates, and comprehensive trade logs. The code will be modular, well-commented, and designed so entries, exits, and position sizing parameters are configurable via a single external file to allow effortless parameter adjustments without modifying core logic. The software will run fully offline on your Windows 10 PC, ensuring reproducibility and privacy. Deliverables include: - Clean, documented source code - Setup and dependency instructions - Sample CSV/HTML reports matching your hand-checked samples for validation I welcome sharing previous relevant projects and GitHub references upon request. Let’s collaborate on building a reliable, maintainable system to advance your trading strategy confidently. Looking forward to your response. Best regards, Mayank
₹18,000 INR in 12 days
5.7
5.7

A backtesting engine is only useful if the numbers hold up under scrutiny, especially when you already plan to validate it against a hand-checked sample. The main thing I’d focus on is making the rule processing deterministic, the metrics transparent, and the parameter changes easy, so you can adjust entries, exits, or sizing without rewriting the engine itself. This fits well with a clean Python implementation for offline use on Windows 10, with commented source, dependency notes, and exportable reports. I’ve worked on custom logic and reporting workflows where the success point was clarity of output and ease of future tweaking, not just “it runs.” If helpful, I can keep the strategy file human-readable so future rule edits stay simple. - Are your indicators standard library-based ones, or do any need custom calculations? - Should the trade log include reason codes for entry/exit, or only timestamps, price, size, and P/L? - How large is the sample dataset you want matched for acceptance?
₹20,000 INR in 7 days
5.2
5.2

Hi, I'd be glad to help build a reliable stock and ETF strategy backtesting engine that runs offline on your Windows 10 machine and cleanly separates strategy logic from parameters. I will develop the engine in Python using standard libraries like pandas and numpy, keeping the core modular so all trade rules, indicators, and position sizing load directly from a single YAML or JSON configuration file. The first step will be setting up the data ingestion and execution model against your hand-checked sample data to ensure trade triggers, slippage assumptions, and equity calculations line up exactly with your manual benchmarks. I have previously built automated systems processing live and historical stock data feeds, custom trade formulas, and performance tracking sheets, so structuring clean trade logs and robust financial calculations is familiar ground. I can cover: • Modular Python backtesting engine with single-file configuration for entries, exits, and position sizing • Performance analytics engine calculating equity curves, maximum drawdown, Sharpe ratio, win rate, and profit factor • Trade log exporter generating clean CSV trade tables and a self-contained HTML performance report • Windows 10 setup guide, requirements file, and verification script using your test dataset I work iteratively with clear validation milestones at each step. Best regards, Gagan
₹15,000 INR in 5 days
4.2
4.2

A reliable backtesting engine depends on clean software architecture as much as trading logic, and my 13+ years building scalable, high-performance applications make me well suited to create a maintainable offline tool for your stock and ETF rules. My JavaScript expertise allows me to build the engine with clearly separated configuration, strategy logic, data handling, and reporting components. I can structure entries, exits, and position sizing as editable parameters rather than values embedded throughout the core code. My backend experience with Node.js, databases, APIs, and performance optimisation supports robust historical-data processing, while my focus on maintainable architecture fits your need for reproducible Windows execution, setup instructions, dependencies, commented source, and CSV or HTML reports. The deliverable can be centered on the metrics you specified equity curve, drawdown, Sharpe, win rate, and complete trade log with results designed for comparison against your hand-checked sample. I would be glad to build a solid, configurable foundation for testing your rules before live use.
₹37,500 INR in 7 days
3.8
3.8

Hi, how are you doing? I have considerable experience building back-testing engines for stock/ETF data and can deliver a reliable, offline Python/C#/JavaScript solution with a clean config-driven setup, well-commented code, setup docs, and a sample report. I can provide a history-driven testbed that outputs equity curves, drawdown, Sharpe, win rate, and a trade log, with parameters editable without touching core code. I can demo past back-testing work if needed. Let me know further if interested.
₹37,500 INR in 5 days
3.4
3.4

Hey, I can handle this easily. I’ve done this exact kind of work 24 times, including one very recently. Are your rules already written as clear entry, exit, and position-sizing conditions? I ask because that determines how to translate them into repeatable tests without guessing what each rule means. I’ll turn your current trading rules into software that can be tested against historical stock and ETF data. How I would run it: 1. Review the rules, data sources, and results you want to see. 2. Build the backtester and test your strategies against historical data. 3. Hand over the source code, setup notes, and results for you to review. I’ll account for transaction costs and avoid look-ahead bias, so the test does not use information that would not have been available at the time. This kind of trading software is familiar territory for me. Do you have a preferred language, such as Python, JavaScript, or C#? Aakash P.S. I recently worked on a similar strategy-testing project. Just send a "Message" so we can talk :)
₹12,500 INR in 14 days
3.3
3.3

Hello, I specialize in building systematic trading back‑testing engines with Python, C#, and JavaScript, designed to run fully offline on Windows 10. I have delivered frameworks for stocks, ETFs, and options that generate equity curves, drawdowns, Sharpe ratios, win rates, and detailed trade logs exactly as you outlined. My approach is modular: all entries, exits, and position sizing rules are parameterized in a single config file, so you can tweak strategies without touching core code. Deliverables will include well‑commented source code, setup instructions, dependency list, and sample CSV/HTML reports showing metrics and trade lists. I emphasize reproducibility—results will match your hand‑checked sample within tolerance, with no survivorship bias or look‑ahead errors. Past work includes custom back‑testing engines for equities and ETFs, integrating price‑action rules with technical indicators, and producing transparent reports for validation. I can share GitHub examples or snippets to demonstrate prior implementations. This milestone will give you a solid, extensible back‑testing foundation, ready for future enhancements like paper trading or live execution. Let’s collaborate to turn your rules into a reliable, testable system.
₹35,000 INR in 7 days
3.4
3.4

Hi - Van Hieu here "STOCK & ETF STRATEGY BACKTESTER" - you need reliable historical results that match hand-checked trades before risking real capital. I'd build this in Python with configurable entries, exits and position sizing in one file. Trade-by-trade accounting will handle open positions, transaction costs and drawdown correctly. I've worked on similar data-driven software before. You'll get commented source code, Windows 10 offline setup instructions, dependencies and a sample CSV/HTML report. Can your hand-checked sample include expected entry and exit prices so I can validate the calculations? Looking forward to work with you. Van Hieu
₹25,000 INR in 5 days
3.0
3.0

Hi — I can build this backtesting engine for you end to end. My plan: a Python engine (pandas + a small indicator layer, no heavy dependencies) that ingests your CSV/Excel price history, replays your entry/exit/position-sizing rules from a single config file, and produces an equity curve, max drawdown, Sharpe, win rate and a full timestamped trade log as CSV or HTML. It runs 100% offline on Windows 10 — one pip install, no server, no internet needed. Before delivery I will validate the output against your hand-checked sample and iterate until the numbers line up exactly, then hand over well-commented code, a dependency list and setup instructions so you can tweak parameters later without ever touching the core engine. I have built similar rule-driven backtesting tools and can start immediately — happy to share a sample structure of the config file before we kick off.
₹16,000 INR in 7 days
2.9
2.9

Hello, I understand you need a reliable Python-based backtesting engine to test your stock and ETF trading rules against historical data and generate detailed performance reports. Here’s what I can provide: - Build a configurable backtesting engine supporting price action, technical indicators, entries, exits, and position sizing. - Generate equity curves, drawdown, Sharpe ratio, win rate, and complete trade logs. - Provide CSV/HTML reports, offline execution, and a simple configuration file for changing parameters. I bring over 4+ years of experience in Python, JavaScript, data analysis, and software development, focusing on reliable and maintainable applications. I can build a modular solution that runs on Windows 10 without requiring an internet connection. Just to clarify a few things: 1. Will you provide historical stock and ETF data in CSV format? 2. Should the engine account for brokerage, slippage, and other transaction costs? Please come to the chat box to discuss more about your project. Best regards Indresh Kushwaha
₹25,000 INR in 7 days
2.4
2.4

Hi, Turning trading rules into a backtester is a good Python job: pandas for the data, a clean rule engine, and honest metrics. - Load historical stock/ETF data (yfinance, Polygon or your source) - Code your entry/exit rules exactly, with fees and slippage - Report CAGR, drawdown, Sharpe, win rate and an equity curve, with trades exported to CSV - Parameter sweeps so you can compare variations Can you share the rules in plain words, and do you have a preferred data source? Alessandro
₹25,000 INR in 14 days
2.5
2.5

Python and software architecture make me well suited to build a reliable, offline back-testing engine around your trading rules. I can structure the application so price history is processed consistently, while entries, exits, indicators, and position sizing remain editable through a configuration file rather than being embedded in the core logic. My 7+ years of IT experience and background in Python, C#, and JavaScript support a clean, maintainable implementation for Windows 10. I will provide well-commented source code, dependency and setup instructions, and a sample CSV or HTML report containing the equity curve, drawdown, Sharpe ratio, win rate, and complete trade log. The architecture can also support comparison against your hand-checked sample so results are reproducible and easy to validate. I am ready to turn your rules into a dependable back-testing foundation that you can adjust and run entirely offline. Choose me to build the first milestone with clarity and maintainability at its core.
₹12,500 INR in 7 days
2.1
2.1

Hi, I can build this backtesting engine in Python, running fully offline on your Windows 10 PC. - Feed in price history from CSV files for any stock or ETF - Entries, exits, position sizing and indicators are all set from one config file, so you can change parameters without touching the core code - Report in HTML and CSV: equity curve, drawdown, Sharpe, win rate and a full trade log - Well-commented source code, a dependency list and setup instructions To match your hand-checked sample, I'll write tests that compare the engine's trades with it, trade by trade, and show you any differences. I'll also state clearly how fills, commissions and slippage are handled, because these assumptions often explain why results differ. Two questions before I start: 1. Which timeframe do your rules use (daily or intraday)? 2. Do you already have the price data, or should I include a data download step? Thanks!
₹15,000 INR in 7 days
2.3
2.3

# Stock & ETF Strategy Backtester Proposal Reviewed your specifications for the Stock & ETF Strategy Backtester project. ## Understanding the Core Problem The goal is to transform your trading rules into a robust software solution capable of backtesting against historical stock and ETF data. This will enhance the precision of your trading strategies and improve decision-making. ## Technical Approach & Architecture We will implement a multi-layered architecture: 1) Data Ingestion Layer: Utilizing APIs from reliable market data providers to fetch historical data. 2) Strategy Logic Layer: Encapsulating your trading rules into modular, reusable components. 3) Backtesting Engine: Leveraging Backtrader for its robust testing capabilities, ensuring the engine supports both stock and ETF data. 4) Reporting Layer: Generating detailed analytics and performance metrics post-backtest. The entire system will be containerized using Docker for consistent deployment across environments, with CI/CD pipelines ensuring automated testing and deployment. ## Deliverables - A fully functional software application that translates trading rules into testable software logic. - A backtesting engine capable of processing and analyzing historical stock and ETF data. - Comprehensive documentation detailing system architecture, usage, and testing procedures. ## Phased Timeline The estimated timeline for project completion is 6 to 8 weeks, with iterative feedback loops every two weeks to ensure alignment with your requirements. ## Key Clarifications 1. Which specific data sources or APIs do you prefer for historical market data? 2. Are there any specific trading rule edge cases that need to be explicitly handled in the software? 3. What level of concurrency and parallel processing do you anticipate during backtesting? ## Next Steps Let's schedule a 15-minute technical alignment call to discuss your specific needs and finalize the project scope. Please let me know your availability for a session this week.
₹12,500 INR in 14 days
1.9
1.9

I can build the back-testing engine in Python so it runs offline on Windows 10: it loads your stock and ETF price history, runs the entry, exit and position-sizing logic from a single config file, and outputs the equity curve, drawdown, Sharpe, win rate and a full trade log, with a sample CSV and HTML report. Source is commented, with setup instructions and a dependency list, and I will check the results against your hand-checked sample before delivery. Delivery 4 days. We have built similar apps for existing clients under confidentiality agreements, so I cannot share them; I can walk you through the architecture. What format is your price history in?
₹12,500 INR in 4 days
1.6
1.6

Since your rules come later, I'd build the engine so a strategy is just a small config plus a signal function, and nothing in the core touches your rules. Python with pandas, runs offline on Windows 10 from a plain CSV folder of daily prices. You'd get the equity curve, drawdown, Sharpe, win rate and a full trade log in an HTML and CSV report. Entry, exit and position sizing live in one YAML file. I'd also run it against your hand-checked sample first, so we agree on the numbers before anything else. Nothing public I can link for this one. Instead I can send a short sample report on public ETF data so you see the output format before funding. Two things decide how exact the match is: do you fill at the next bar's open or at the close of the signal bar, and are commissions or slippage part of your hand-checked sample?
₹15,000 INR in 2 days
1.0
1.0

Bengaluru, India
Payment method verified
Member since Oct 13, 2019
₹1500-12500 INR
₹1500-12500 INR
₹12500-37500 INR
₹12500-37500 INR
₹12500-37500 INR
₹12500-37500 INR
$30-250 CAD
$30-250 USD
₹1500-12500 INR
$750-1500 USD
$3000-5000 USD
$10-30 CAD
₹1500-12500 INR
₹600-1500 INR
$40-60 USD / hour
$750-1500 USD
$250-750 USD
₹1500-12500 INR
₹12500-37500 INR
₹1875 INR
$10-30 CAD
$250-750 USD
₹12500-37500 INR
₹12500-37500 INR
$30-250 USD