← Rajandran R's posts

The Cost of Building OpenAlgo

View Original ↗

OpenAlgo V1.0 officially started around 8 April 2024.

At that time, it was mostly curiosity.

I had a $20 ChatGPT subscription, a bunch of ideas around trading automation, and the urge to see how far AI-assisted development could go.

There was no large engineering team.

There was no big infrastructure budget.

There was no plan to support 35+ brokers.

It simply started with:

$20 per month.

Fast forward to September 2026.

The estimated amount spent building, testing and maintaining OpenAlgo is now around:

₹44.5 lakh

But this blog is not really about that number.

It is about something I think people often misunderstand about open source.

Open source does not mean free software.

At least, not for the people building it.

The source code may be available for everyone.

You may be able to download it for free.

You may be able to modify it, study it and run it on your own machine.

But somewhere, somebody is paying the cost.

Sometimes with money.

Mostly with time.

Very often with energy.

And keeping something open source for years requires something even harder to measure:

the willpower and curiosity to keep exploring how far the project can go.

OpenAlgo is one example of that journey.

April 2024: $20 Was Enough

OpenAlgo initially started with ChatGPT 4.

The workflow was simple.

Ask ChatGPT.

Generate some code.

Understand it.

Modify it.

Test it.

Repeat.

At that stage, AI was mostly a coding assistant.

The monthly cost was approximately:

$20

For someone experimenting with software ideas, it felt almost magical.

You could suddenly attempt things that previously required much more programming effort.

But things changed quickly.

Then Came API-Based Coding

Around June 2024, I started experimenting with direct AI APIs.

OpenAI.

Anthropic.

Amazon Bedrock.

Cline inside VS Code.

This was very different from simply chatting with an AI.

The models could work with larger parts of the codebase.

They could inspect files.

Modify code.

Understand architecture.

Debug problems.

Implement larger features.

Productivity jumped enormously.

Unfortunately, so did the bill.

AI usage quickly reached around:

$20 to $40 per day

Some months were approximately:

$880

From a $20 monthly subscription to almost $900 per month within a few months.

The productivity improvement was enormous.

But everything was metered.

Every agent loop consumed tokens.

Every experiment consumed tokens.

Every wrong implementation consumed tokens.

Even asking an agent to rethink its own solution had a cost.

AI coding suddenly became incredibly powerful and incredibly expensive at the same time.

Windsurf Changed the Economics Again

Then tools such as Windsurf started offering premium plans.

For a few months, the cost of AI-assisted coding became much more predictable.

Instead of constantly thinking about token usage, I could operate at roughly:

$120 per month

That was a huge improvement.

But OpenAlgo itself was becoming much larger.

More APIs were being added.

More brokers were being integrated.

More features were being built.

More users were testing the platform.

And the biggest cost slowly stopped being AI.

It became people.

From a Personal Project to a Small Team

At some point, OpenAlgo became too large to build and maintain completely alone.

A colleague joined the development effort.

Interns were added.

That introduced another kind of work.

Explaining architecture.

Teaching how broker APIs work.

Reviewing implementations.

Testing features.

Finding edge cases.

Checking whether something that worked for one broker also worked with another.

The human development cost gradually moved to approximately:

$1,200 per month

This taught me something important.

Writing the first version of a feature is often the easy part.

Maintaining it is where the real work starts.

Then Claude Code Arrived

Claude Code pushed agentic coding another step forward.

Instead of asking AI to write isolated functions, you could assign much larger engineering tasks.

Read the repository.

Understand the issue.

Implement the change.

Run tests.

Fix failures.

Repeat.

Development speed increased again.

Claude Code added approximately another:

$400 per month

Around the same period, I started using more coding models and tools.

The broader development stack has included tools such as ChatGPT, Claude Code, Codex, OpenCode and Grok.

Codex alone has been around $200 per month during recent months.

OpenCode is around $20 per month, mostly experimental.

Grok has been approximately $20 per month for around two years.

AI is no longer just a subscription.

It has effectively become part of the engineering infrastructure.

The Cost Nobody Thinks About: Brokerage

Building an algo trading platform has another unusual development expense.

Brokerage.

If you are building a normal SaaS product, testing a button may cost nothing.

If you are building a trading platform, testing a button can place a real order.

During the early stages of OpenAlgo, we were doing a lot of manual live testing.

Place an order.

Cancel it.

Modify it.

Test a market order.

Test a limit order.

Test stop loss.

Test positions.

Test holdings.

Test another exchange.

Test another broker.

Then repeat everything again.

During some of the initial months, brokerage charges were around:

₹12,000 to ₹14,000 per month

And this was not trading.

This was software testing.

Sandbox Trading Changed the Economics

Eventually, it became obvious that testing every workflow using real orders was inefficient.

So we invested heavily in building a sandbox environment.

Once sandbox testing improved, brokerage costs dropped dramatically.

Today, even with support for 35+ brokers, typical brokerage and live QA costs are closer to:

₹4,000 to ₹5,000 per month

Most development can now happen safely before touching a real broker account.

The sandbox reduced cost, risk and testing time.

It is probably one of the most valuable engineering investments we made.

But Broker APIs Never Stand Still

Broker integrations are not something you build once and forget.

APIs change.

Authentication changes.

Websocket behaviour changes.

Compliance rules change.

Exchange requirements change.

Order responses change.

A good example happened around April 2026 when brokers started implementing static IP related compliance requirements.

That triggered another round of integration work and live testing.

Brokerage expenses during that period went up to approximately:

₹24,000 in a single month

Supporting 35+ brokers does not mean writing 35 adapters once.

It means maintaining 35 moving targets.

Why We Started Doing Broker QA Audits

As OpenAlgo grew, we realised that testing itself needed better infrastructure.

So we started building structured Broker QA Audit tools.

The objective is simple:

The same OpenAlgo API should behave predictably regardless of which broker is connected underneath it.

Every broker behaves slightly differently.

Authentication is different.

Order statuses are different.

Error responses are different.

Websocket implementations are different.

Symbol formats can be different.

Rate limits are different.

Sometimes even basic interpretations of order states are different.

This is why a lot of OpenAlgo engineering work today happens in places users never see.

Regression testing.

QA audits.

Sandbox testing.

Automated validation.

Manual broker testing.

AI Made Coding Faster. Verification Became the Bottleneck.

This is probably the biggest change I have observed over the last two years.

In traditional software development, writing code was often the bottleneck.

Today AI can generate code incredibly fast.

Sometimes too fast.

An AI agent can modify 20 files before a human has properly reviewed the first five.

That creates a different engineering problem.

The bottleneck is shifting from:

Writing code

to:

Verifying code

Did the feature actually work?

Did the agent misunderstand the requirement?

Did it break another broker?

Did it introduce a security issue?

Did it handle failure conditions?

Did it only work for the happy path?

Did it silently change existing behaviour?

This is why a significant amount of our effort now goes into QA, testing and validation.

AI dramatically increased our ability to produce software.

It did not remove the need to prove that the software is correct.

Building the Software Was Only Half the Work

Another thing we gradually understood is that building a feature is not enough.

Most OpenAlgo users are traders and investors.

They come from Tier 1, Tier 2 and Tier 3 cities across India.

And many of them are not developers.

They may understand markets extremely well.

They may understand options, futures, technical analysis, execution, market structure or systematic trading.

But that does not necessarily mean they know Python, REST APIs, Docker, GitHub, terminals, environment variables or deployment.

That creates another responsibility.

If we build something powerful but users cannot understand how to use it, the job is only half done.

A significant amount of energy has gone into writing tutorials, improving documentation, recording videos, creating examples and explaining technical concepts in a way traders can understand.

We have also increasingly explored AI tools and assistants to help bridge this gap.

If AI can help a trader understand an API, configure a strategy, diagnose an error or learn how a feature works, then AI is not just helping us write OpenAlgo.

It is helping OpenAlgo reach more traders and investors.

That accessibility work is also part of building the platform.

Documentation Is Also Engineering

Documentation is often treated as something you do after the software is finished.

For OpenAlgo, that does not really work.

A new broker integration needs documentation.

A new API needs documentation.

A new charting feature needs documentation.

A change in authentication needs documentation.

A new sandbox workflow needs examples.

A new trading feature may need screenshots, tutorials and videos.

Sometimes the code for a feature may take a few hours.

Explaining that feature properly to thousands of users can take much longer.

And because OpenAlgo serves traders with very different technical backgrounds, documentation has to work for both ends of the spectrum.

A developer may want the exact API payload.

A trader may simply want to know:

Where do I click? What does this do? How do I know it is working?

Both are valid users.

Both matter.

Sometimes the Best Feedback Is Painful

Anyone building software publicly will eventually hear things like:

“Your software is trash.”

It is easy to dismiss comments like that.

But sometimes there is useful information hidden inside the frustration.

Maybe installation is too difficult.

Maybe the documentation is unclear.

Maybe the interface is confusing.

Maybe the user expected something obvious that we completely missed.

Maybe an important workflow takes too many steps.

Maybe technically everything works, but the experience is still poor.

So whenever someone says something is bad, I try to ask a more useful question:

What are we missing?

What frustrated this person?

What is missing from the OpenAlgo ecosystem?

Can the workflow be redesigned?

Can it be automated?

Can AI simplify it?

Can we remove another technical barrier?

Can we explain it better?

Can we build a tool that makes the problem disappear entirely?

Not every criticism will be correct.

But criticism is still data.

Sometimes the harshest feedback exposes problems that regular users quietly tolerate without ever reporting.

That feedback loop has shaped OpenAlgo continuously.

What Is Missing From the OpenAlgo Ecosystem?

This is one question I keep asking.

Not simply:

What feature should we add next?

But:

What is stopping a trader from taking an idea and turning it into a working automated trading system?

Sometimes the answer is a broker integration.

Sometimes it is charting.

Sometimes it is backtesting.

Sometimes it is risk management.

Sometimes it is alerts.

Sometimes it is a sandbox.

Sometimes it is documentation.

Sometimes it is education.

Sometimes it is simply making an existing feature easier to understand.

And increasingly we ask another question:

Can AI remove this barrier?

The purpose is not to add AI because AI is fashionable.

The purpose is to see whether technology can reduce the distance between a trader having an idea and being able to experiment with that idea.

Sometimes You Have to Leave the Laptop

Not everything can be understood from GitHub issues, analytics or online discussions.

Sometimes you have to meet people.

Over the years, I have travelled to meet developers, traders, OpenAlgo users and people from the broader ecosystem.

Those conversations are extremely valuable.

A trader sitting across the table explaining how they actually work can expose problems that may never appear in a GitHub issue.

Sometimes a requirement that initially sounds unusual makes complete sense once you understand the person’s workflow.

Sometimes users are using OpenAlgo in ways we never imagined while building the feature.

Sometimes they show exactly where the friction is.

Those conversations influence what gets built next.

OpenAlgo is not shaped only by code.

It is shaped by listening to traders.

Understanding their pain.

Understanding their requirements.

Watching how they actually use the platform.

And trying to make OpenAlgo a little better every single day.

Travel, conversations and community engagement are also part of the cost of building OpenAlgo.

They are simply much harder to represent in a spreadsheet.

Infrastructure Is a Continuous Expense

OpenAlgo also requires servers and development infrastructure.

Our average server and infrastructure cost is approximately:

₹10,000 per month

Across roughly 30 months, that alone is around:

₹3 lakh

Then there is the hardware used for development.

Computers and related hardware have cost approximately:

₹3.5 lakh

These are easy costs to overlook when calculating the cost of open-source software.

GitHub may be free.

The source code may be free.

The infrastructure required to continuously develop and test that software is not.

Even Communication Has Infrastructure

Another unusual cost is content and communication.

We built tools such as Sketchmaker to help create visual content for social media.

The infrastructure and APIs behind that cost approximately:

₹5,000 per month

Across 30 months:

₹1.5 lakh

Medium, Cloudflare and other smaller publishing services add another recurring cost.

Individually, these numbers look small.

Over multiple years, everything adds up.

Rough Cost of Building OpenAlgo

As of September 2026, the approximate expenditure looks something like this:

These are approximate numbers.

Some months were much cheaper.

Some months were significantly more expensive.

There are also smaller expenses that are not included.

Travel, events, education, community interaction and various operational expenses are not fully represented here.

One Very Important Cost Is Missing

My own time.

From April 2024 until today, a huge number of hours have gone into coding, testing, documentation, broker integrations, debugging, community support, reviewing pull requests, experimenting with AI tools, building infrastructure, recording videos, writing tutorials, travelling to meet users and simply observing how traders actually use OpenAlgo.

I have intentionally not assigned a monetary value to that time.

If I did, the true economic cost of OpenAlgo would be significantly higher.

And time is only one part of it.

Open source requires energy.

You build something.

Someone finds an issue.

You fix it.

Someone requests another broker.

You explore it.

A broker changes its API.

You revisit old code.

Someone contributes a pull request.

You review it.

A regulatory change happens.

A dependency changes.

An AI agent introduces a regression.

Someone says the software is terrible.

You investigate whether they discovered something you missed.

You improve it.

And you keep going.

That cycle never really ends.

Then Why Are We Spending This Much on Something Free?

This is probably the obvious question.

If OpenAlgo costs real money to build and maintain, what is the business model?

When will subscriptions start?

When will investors come in?

When will brokers sponsor it?

When will the free version disappear?

We have been asked versions of these questions almost from the beginning.

And we answered them publicly very early in the journey.

On 6 July 2024, only a few months after OpenAlgo officially started, I published our commitment to the community.

The position was simple:

OpenAlgo would remain free and open source for retail users.

More than two years later, that commitment has not changed.

And we intend to continue with it.

OpenAlgo Is Not a VC-Funded Company

OpenAlgo is not being built with the objective of becoming another venture-funded fintech startup.

We are not preparing a pitch deck.

We are not trying to raise VC funding.

We are not chasing valuation.

We are not building towards an eventual funding round.

OpenAlgo is self-funded and bootstrapped.

That gives us something extremely valuable:

freedom to decide what OpenAlgo should become.

We can explore ideas because they are interesting.

We can build something because traders need it.

We can spend weeks solving a technical problem without having to justify whether it improves quarterly revenue.

Not everything has to become a business model.

Sometimes curiosity itself is enough reason to build.

Why We Declined Broker Sponsorships

As OpenAlgo grew, brokers approached us with sponsorship opportunities.

Good brokers.

Serious offers.

We declined them.

That was a conscious decision.

OpenAlgo sits between traders and brokers.

If one broker starts funding the project, even with the best intentions, questions naturally arise.

Does that broker receive priority?

Does their integration get more attention?

Are recommendations influenced?

Will another broker be treated differently?

Even the perception of that conflict matters.

So we decided that OpenAlgo should remain:

broker neutral.

We integrate brokers because traders use them.

We fix broker integrations because users need them.

We should be able to say that without someone wondering whether money influenced the decision.

That independence is worth protecting.

Users Have Offered Us Money Too

Users who found OpenAlgo useful have also offered financial support.

We are grateful for that gesture.

But we declined those offers too.

What helps an open-source project most is participation.

A trader who identifies a reproducible problem and provides screenshots, logs and context can save hours of investigation.

Someone who improves a tutorial or documentation can help hundreds of other users.

Someone who tests a new release can uncover issues before they affect the wider community.

And developers can contribute code where they have the knowledge and time to do so.

OpenAlgo now has 85+ contributors, which is a great sign of how much the ecosystem has grown.

But growth creates another challenge.

There can be 150+ pull requests waiting to be reviewed, tested or approved.

Code contributions themselves also require maintenance energy.

Every significant change has to be understood, tested for regressions, checked for security implications and sometimes validated across multiple brokers.

Open source works best when contribution is viewed not only as submitting code, but as sharing the responsibility of making the software better.

Broker Neutrality Matters to Us

Supporting 35+ brokers makes independence especially important.

Our objective is not to tell traders which broker they should use.

Our objective is to provide a common technology layer where traders can choose their broker and still use the same OpenAlgo ecosystem.

One broker may have better APIs.

Another may have different features.

Another may suit a particular trader better.

Those are decisions traders should make themselves.

Our job is to make OpenAlgo work as predictably as possible across them.

That is why we want to remain independent.

No broker sponsorship deciding our roadmap.

No VC telling us what needs to be monetized.

No investor asking which feature generates revenue.

Just users, contributors, technology and curiosity shaping the direction of the project.

Our July 2024 Commitment Still Stands

When we published our commitment in July 2024, OpenAlgo was still young.

It is easy to make promises when a project is small and inexpensive.

The real test comes when the project grows.

More than two years have passed.

The codebase has grown.

The number of brokers has grown.

The community has grown.

Development costs have grown.

Infrastructure costs have grown.

The complexity of maintaining OpenAlgo has grown enormously.

But our position remains the same.

OpenAlgo remains open source.

OpenAlgo remains free for retail users.

We remain self-funded and bootstrapped.

We are not planning to raise VC funding for OpenAlgo.

We continue to remain broker neutral.

That is not a position we created recently because it sounds good.

It is something we stated publicly in July 2024 and have continued to follow as the project expanded.

Open Source Is Free to Use. It Is Not Free to Build.

This is really the reason I wanted to write this article.

When people hear “open source”, there is sometimes an assumption that open source means free software.

For the user, it often is.

For the creator, it almost never is.

There is money involved.

There is infrastructure involved.

There are machines involved.

There are API bills.

There are developers.

There is testing.

There is documentation.

There are tutorials.

There are videos.

There is community support.

There is travel.

But above all, there is time and energy.

Keeping a project open source requires another ingredient.

Willpower.

You have to genuinely enjoy exploring the problem.

You have to remain curious enough to keep pushing the limits.

You have to be willing to share what you build even when keeping everything private might sometimes be easier.

And you need enough conviction to continue doing it even when monetizing, taking sponsorships or raising capital might be the easier path.

That curiosity and independence are probably what have kept OpenAlgo moving from a small experiment into what it is today.

AI Reduced the Cost of Ambition

AI made it possible for a very small team to build something that would previously have required a much larger engineering organisation.

That represents an enormous reduction in the cost of software creation.

But something interesting happens when productivity increases.

You do not necessarily spend less.

You start building more.

Instead of building five features, you build fifty.

Instead of supporting five brokers, you try supporting thirty-five.

Instead of stopping with an API layer, you start building charts, sandbox systems, risk management, alerts, voice agents, QA tools, documentation systems and developer infrastructure.

AI reduced the cost of ambition.

And when ambition becomes cheaper, the boundaries of the project expand.

The Most Expensive Part Is No Longer Code

If there is one thing I have learned from building OpenAlgo, it is this:

The cost of producing code is collapsing.

But the cost of trust is not.

Neither is the cost of understanding your users.

You still have to test the software.

You still have to audit it.

You still have to understand it.

You still have to document it.

You still have to explain it.

You still have to listen when users tell you something is wrong.

You still have to maintain it.

And when that software interacts with real trading accounts and real money, correctness matters far more than how quickly the code was generated.

OpenAlgo started as a $20 experiment.

What keeps it moving today is not just money.

It is curiosity, time, energy, independence and a community willing to participate.

Our commitment from July 2024 still stands.

Open source may be free to use.

It is never free to build.