BotHouse

bot-programming e-commercial

Comment

BotHouse

Inspiration

When I was 14, I moved to another city and suddenly had a lot of free time. I wanted to get into software development, but programming languages such as Python and Node.js looked intimidating to me. I was afraid that programming would be too difficult.

Around that time, I became more active on Discord, and a friend introduced me to Bot Designer For Discord (BDFD). I downloaded it out of curiosity, and I quickly realized that it was much more than a bot-building application. It was a simple and surprisingly effective way to learn programming fundamentals.

BDFD introduced concepts such as commands, conditions, and basic algorithms without forcing beginners to understand the complexity of a traditional programming language first. Because of its community and accessible structure, I found that some beginners could understand algorithmic thinking through BDFD more easily than they could through Python.

I started teaching BDFD to friends who were interested in programming but were intimidated by English-language resources and traditional programming languages. Eventually, I created my own learning system:

BDFD → JavaScript/Aoi.js → Node.js → Software Development

The idea was to use a simple environment to teach programming fundamentals first, then gradually move students toward real programming.

However, I kept receiving questions about BDFD:

"Why does this function exist?" "Why doesn't it have this feature?" "Why can't I do this?"

That led me to a bigger idea:

What if I built the language myself, connected it to a proper server infrastructure, and made it capable of powering bots across different platforms?

At the same time, I realized that the same infrastructure could solve a completely different problem: e-commerce businesses spend significant amounts of money and time building and maintaining automation systems.

For the past three years, I have focused on building the skills required to turn this idea into reality. During the first year, I focused heavily on JavaScript. In the second year, I moved into mobile development. During the third year, I focused on interpreter development, backend architecture, and server management.

That journey eventually became BotHouse.

What it does

BotHouse allows users to create and run their own bots using a programming language designed to be significantly easier to understand than traditional programming languages.

Instead of dealing with complex infrastructure, users can provide their bot information to the platform and start building their automation with a simple language.

BotHouse is designed for two major groups:

Beginners

People who want to learn programming can create real, functional bots while learning programming concepts along the way.

Instead of starting with thousands of lines of code, users can begin with a much simpler syntax and gradually understand how programming works.

E-commerce businesses

Businesses can use BotHouse to automate repetitive operations without having to build and maintain an entire backend infrastructure themselves.

This can reduce the technical complexity and infrastructure costs associated with automation.

BotHouse also introduces an ad-supported hosting model. Users who cannot afford hosting can watch advertisements to help cover their server costs.

For premium features, we use RevenueCat to manage subscriptions and in-app purchases across the platform. This allows us to maintain a centralized and scalable system for handling premium access and revenue while keeping the core platform accessible to users who cannot afford paid hosting.

Our goal is simple:

Make automation accessible to people who know how to code, people who are learning to code, and people who have never coded before.

How we built it

The client application was built with Flutter.

I developed the core application logic, service integrations, and platform functionality myself. I also used AI tools to accelerate UI development and iteration, allowing me to spend more time on the underlying architecture.

Backend

For the backend, I built a server architecture primarily using Go.

One of the biggest architectural decisions was using a Multi-Tenant, Single-Process approach.

Instead of running a completely independent process for every bot, multiple bots can operate within the same server process while remaining logically isolated.

This was challenging because memory management and resource allocation had to be carefully considered.

I experimented with pooling and resource-management strategies and eventually built an architecture where a bot could operate with approximately 1 MB of RAM on average under our tested workload.

On a server with 6 GB of RAM, I was able to run approximately 1,000 bots in testing.

Interpreter

The most technically important part of BotHouse is its interpreter.

I developed the language myself using a traditional:

Lexer → Parser → Interpreter

architecture.

I implemented the core language infrastructure and designed the system so that commands can communicate with different platforms through the appropriate modules or APIs.

This means that the same high-level BotHouse language can eventually interact with different services without forcing the user to learn the implementation details of every platform.

Challenges we ran into

One of the biggest challenges was connecting thousands of potential bot environments to a common language while keeping the server architecture efficient.

Building the multi-tenant architecture, managing bot resources, designing the interpreter, and making everything communicate reliably required solving problems that I had never encountered before.

My previous three years of experience helped me solve many of these problems, but I still had to research unfamiliar concepts and understand new architectures.

I also used AI tools as a learning assistant: rather than simply copying generated code, I used them to summarize complex concepts, compare approaches, and help me understand the underlying systems.

The biggest challenge was not writing the code.

It was understanding why the architecture should work the way it does.

Accomplishments that we're proud of

Before building BotHouse, we created an educational community called RUDS Development.

Through BDFD-based programming education and educational content on YouTube, we helped more than 150 people take their first steps into programming.

That experience directly influenced BotHouse.

We learned that beginners don't necessarily need a simpler version of a programming language.

They need a different starting point.

BotHouse is our attempt to build that starting point while also creating infrastructure that can eventually support real-world automation and e-commerce use cases.

Our long-term goal is to take the accessibility that made BDFD successful and remove the limitations that come with it.

What we learned

AI has fundamentally changed software development.

Today, someone can describe what they want and generate a working implementation within seconds.

But that does not eliminate the need for programming knowledge.

If something goes wrong, security needs to be reviewed, infrastructure needs to be maintained, or generated code needs to be modified, someone still needs to understand what is happening underneath.

While building BotHouse, I learned much more about:

  • Interpreter architecture
  • Lexers and parsers
  • Memory management
  • Multi-tenant systems
  • Backend architecture
  • Server resource management
  • API integration
  • Mobile application development

But perhaps the most important lesson was that small systems can become powerful when they are designed to work together.

A simple language, an interpreter, a server architecture, an educational system, and a sustainable business model can become something much larger when they are connected correctly.

What's next for BotHouse

There is a lot more planned for BotHouse.

A better UI

The current UI was developed under significant time constraints for the competition. We plan to redesign and improve the interface to make the entire experience more intuitive and polished.

More commands

We currently have a growing command system, and our next major milestone is reaching approximately 300 supported commands, allowing users to build significantly more complex automations without leaving the BotHouse ecosystem.

Account synchronization

We plan to introduce Google Sign-In and a shared cloud database so users can securely access and manage their bots across different devices.

Security

Bot tokens and other sensitive credentials require serious protection.

As the platform grows, we plan to implement a stronger security architecture across both the client and server sides, including secure credential handling, isolation, access control, and protection against unauthorized access.

BotHouse:Block

Not everyone wants to write code.

For users who cannot read or write code comfortably, or simply don't want to type commands manually, we plan to create a companion platform called BotHouse:Block.

Users will be able to build bot automations using visual blocks instead of writing code.

This would create a progression like:

BotHouse:Block → BotHouse Language → Traditional Programming

Users could start visually and eventually transition into actual programming if they want to.

AI-powered development

We also plan to develop an AI assistant specifically designed around the BotHouse language.

The system could be built on top of models such as Qwen or other open-source language models and fine-tuned to understand BotHouse's syntax and ecosystem.

Instead of asking an AI to generate Python or JavaScript, users could simply describe what they want and receive BotHouse code.

Because BotHouse is designed to express common automation tasks with much less code, the same task could potentially require significantly fewer tokens than an equivalent implementation in a traditional language.

On-device bot execution

One of our longer-term premium features is local bot execution.

The idea is to allow users to run their bot directly on their own device while using the BotHouse server only for license verification and essential platform services.

This could allow bots to operate without continuously sending their execution data to a third-party server.

Sustainable monetization

We want BotHouse to remain accessible while also being financially sustainable.

Our model combines:

Free access + Ad-supported hosting + Premium features

For premium subscriptions and in-app purchases, we use RevenueCat to centralize subscription management and entitlement handling.

This allows us to focus on building the platform itself instead of maintaining separate purchase and subscription infrastructure for every platform.

Ultimately, our goal is to build an ecosystem where learning programming, building bots, deploying automation, and running an online business can exist within the same platform.

BotHouse is not just a bot builder.

It is an attempt to make programming and automation accessible to everyone.

Built With

Share this project:

Updates

Submission history