BattleStation: Streamlining Local Development for Our Microservices Backend

Developing in a microservices architecture can be both empowering and overwhelming. On the one hand, breaking functionality into smaller, independent services allows for scalability, modularity, and clear ownership. On the other, the complexity of running and coordinating multiple services and databases locally can quickly become a burden.

At Cognitive3D, our backend is built on microservices. Instead of one massive application doing everything, we have many focused services that communicate with each other. This approach has served us well, but it presents unique challenges for local development.

The Problem: Local Microservice Overhead

Let’s take a real example: Melder, a core service in our data pipeline that stitches together sessions from raw data streams.

To function properly, Melder depends on:

• SQLConnector and ExitPollConnector services

• Cassandra and Elasticsearch databases

• Two SQL databases: SceneDB and ExitPollDB

  
  

That means, just to test Melder locally, one needs to spin up multiple services and four separate databases—all while making sure they are pointed at the correct environments.

In practice, this translated into:

• A dozen terminal tabs running various services and database connections
• 10–15 minutes of setup time before even beginning development
• Significant mental overhead from context-switching between tools, logs, and environments

The Hackathon Spark

During our May 2025 hackathon, we wanted to solve this pain point. What if there was a single tool where developers could see all their dependencies at a glance and launch them with a click?

With a group of our engineers gathered around the big dining table at our offsite, we built the first prototype of what we now call BattleStation.

What Is BattleStation?

BattleStation is a GUI application that acts as a control center for local development. Think of it as a blank canvas, dynamically populated by modules defined in a simple YAML configuration file.

Each module appears as a “card” in the app and can represent:

• A microservice
• A port forward (to a remote database or service)
• (Soon) a Docker app

Features that make a difference:

• Start/Stop Buttons – Launch or shut down modules instantly.

• Resource Monitoring – CPU and memory usage displayed on each card.

• Logs Panel – Live logs without needing another terminal.

• Environment Selector – Switch between dev/staging/test environments.

• Microservice Power Tools – Git branch selector, Git pull button, and quick-launch terminal access.

  
  

Modules can be grouped into tabs, making it easy to organize workflows around a specific service or project. A single button at the top lets you start/stop all modules in a tab at once.

We even integrated a terminal emulator inside the app. For microservices, clicking the terminal button drops you into the correct directory with git status already run—perfect for resolving conflicts or performing advanced tasks.

The Impact

Before BattleStation, spinning up Melder took ~15 minutes and constant vigilance. With BattleStation, we can do it in under a minute, without juggling multiple terminals or worrying about misconfigured environments.

The result:

• Less friction in development workflows
• Fewer mistakes connecting to the wrong databases
• Faster iteration on complex services
• Lower cognitive load for developers

What’s Next

BattleStation is already a big productivity win, but this is just the beginning. Our vision is to evolve it into a Swiss Army knife for internal development tooling—a foundation we can extend to other needs beyond service orchestration.

For now, it’s our go-to control center for taming the complexity of microservices in local development—and it’s saving us time and headaches every single day.

---