MirrorInSeconds

Mirror your software for QE and Demo's without toching prod.

Comment

MirrorInSeconds

Inspiration

Demos and QA always hit the same moment:

“What happens if the webinar is already full?”

Now someone has to:

  • create test users
  • modify the database
  • restart the app
  • pray the state matches the scenario

It wastes time and breaks the flow of demos.

We wanted a way to instantly recreate any product situation without manually preparing environments or data.

So we built MirrorInSeconds — describe a situation, and a live version of the app in that state spins up.

What it does

MirrorInSeconds creates a runnable copy of your application in seconds, already configured with the situation you want to test.

Example prompt:

student opens a webinar and the webinar is full

Instead of manually preparing data, MirrorInSeconds:

  • generates synthetic database data using GenAI
  • spins up a MongoDB container
  • seeds it with that scenario data
  • builds the application from the GitHub repo
  • launches the app in a sandbox

You instantly get a live URL to interact with the app in that exact situation.

Perfect for:

  • product demos
  • QA scenario testing
  • reproducing edge cases
  • exploring "what happens if..." flows

How we built it

1. Project onboarding

A developer pastes a GitHub repository URL to onboard a new project.

An MCP server analyzes the repo and automatically detects:

  • application roles (admin, user, student, etc.)
  • database collections / schema structure

Those fields get auto-populated in the project setup.

2. Scenario generation

The user writes a short scenario like:

student tries to register but webinar is full

GenAI then generates:

  • synthetic database data for that situation
  • a login + password for the scenario role
  • the collections needed to represent that state

3. Launching the sandbox

When the user clicks Launch:

  1. the GitHub repo is cloned
  2. a Docker image is built
  3. a MongoDB container is started
  4. the synthetic data is seeded into the database
  5. the application container is launched with the sandbox DB

Everything runs inside isolated containers.

4. Live environment

Within seconds the system returns a live URL.

The developer can open it, log in using the generated credentials, and experience the exact scenario inside the app.

No manual setup.
No staging database manipulation.

Just prompt → environment → test.

Challenges we ran into

  • Dynamically seeding databases with unknown schema structures
  • orchestrating multiple Docker containers per scenario
  • ensuring MongoDB is ready before seeding data
  • safely executing repo cloning and container builds

Basically… building a tiny environment orchestration system.

Accomplishments that we're proud of

  • turning natural language scenarios into runnable environments
  • auto-detecting roles and database structures from repos
  • generating scenario-specific synthetic data
  • launching fully isolated sandbox apps in seconds

Seeing a prompt instantly become a live app environment felt magical.

What we learned

This project taught us a lot about:

  • container orchestration with Docker
  • automated environment creation
  • AI-generated datasets
  • connecting AI reasoning with real infrastructure

We realized debugging and QA could become much more interactive and scenario-driven.

What's next for MirrorInSeconds

Next we want to expand MirrorInSeconds into a full debugging assistant:

  • reproduce bugs from support tickets
  • snapshot and replay user scenarios
  • support Postgres, Redis, and microservices
  • attach sandbox environments directly to GitHub issues

The goal:

Any product scenario should be one prompt away from running.

Built With

  • Node.js
  • Express
  • React
  • Docker
  • MongoDB
  • AWS EC2
  • GenAI for synthetic data generation
  • GitHub

Built With

Share this project:

Updates