Introducing Scotty: A Micro-Platform-as-a-Service for Effortless App Management
Why every development team needs better preview apps
Picture this: It is Monday morning, and your development team has three feature branches ready for review. Sarah from QA needs to test the new checkout flow. The product manager wants to see the updated dashboard design. Your client is eager to preview the integration they requested last week.
In a traditional workflow, that often means asking developers to deploy manually to a shared staging environment and hoping nothing conflicts. It may require walking non-technical stakeholders through complicated localhost setup. It can turn you into a deployment queue manager as teams compete for limited test environments. Or worse, it leads to reviewing changes only in code and hoping for the best.
This is the ephemeral environment problem, and it costs development teams hours every week.
The gap in modern development workflows
Platforms like TugboatQA and Qaack have stepped in with sophisticated serverless solutions. TugboatQA offers preview environments with visual regression testing and Lighthouse integration. Qaack provides Web Environment Management across multiple frameworks and hosting providers.
GitHub Codespaces and Gitpod excel at instant development environments, but sharing remains developer-centric. Port forwarding and temporary URLs work for technical team members. Stakeholders who simply need a stable link still encounter friction.
These solutions are powerful, but they bring setup effort, ongoing configuration, and often enterprise-level pricing. Many teams ask a simpler question: What if we just want to spin up our Docker Compose apps for review, without the overhead?
The Docker Compose reality
Most teams already run Docker Compose smoothly on their local machines. Services connect, databases communicate, and the app behaves as expected. But sharing that working application with others becomes the bottleneck.
The step from “it works on my machine” to “it works for stakeholder review” should not require rewriting deployment configs, learning a new platform, migrating away from Docker Compose, or adopting orchestration designed for production.
What teams really need
Teams need instant shareability that turns docker-compose up into a public URL. They need zero configuration overhead and the ability to use existing Compose files. They need automatic cleanup so environments disappear when no longer needed. They need URLs that non-technical stakeholders can actually use. And they need integration flexibility to fit into existing CI/CD pipelines.
This is exactly the problem Scotty was built to solve.
Your Docker Compose apps, now shareable
Scotty grew out of real project work at Factorial. We often needed to share development progress with clients and stakeholders. Existing tools felt like using a sledgehammer to crack a nut. We did not need enterprise orchestration; we needed a simple way to make Docker Compose apps publicly accessible with minimal effort.
At its core, Scotty is a micro-Platform-as-a-Service (µPaaS) that does one thing exceptionally well: it takes your existing Docker Compose applications and makes them instantly accessible on the web. Think of it as the Star Trek transporter for your apps—“beaming” them from your local machine to a server with a proper URL that anyone on the team can open.
If it runs with docker-compose up on your laptop, Scotty can run it on a server and give it a URL. No rewrites, no migrations, no new patterns to learn. Your docker-compose.yml remains the single source of truth for local and remote runs.
What sets Scotty apart is intentional focus. It does not try to solve every deployment problem. It excels at one use case: making Docker Compose apps instantly shareable. Apps are ephemeral by default and clean themselves up after a configurable lifetime. A simple web interface lets non-technical colleagues check status or restart applications.
The name “Scotty” nods to Star Trek’s engineer who could beam people and objects from one place to another. Here, we beam Docker Compose apps from local development to a shared server. The application runs the same way remotely as it does locally.
The sweet spot use cases
Scotty is ideal when you need the functionality of a deployed application without the permanence or complexity of production.
Review applications
Review applications are the obvious fit. Instead of asking a product manager to set up Docker or sending screenshots, deploy the branch to Scotty and share a URL. Stakeholders click through the real interface, test real functionality, and give feedback on the working application.
Quality assurance
Scotty eases the handoff between “I built this feature” and “does it work as intended?”. QA can test features in isolation without conflicts. Product managers can evaluate flows in a real browser. Clients can see progress without understanding deployment internals.
Ephemeral applications
Automatic cleanup is especially helpful for agencies and consultancies. Spin up a polished preview for a client presentation, set it to destroy after the meeting, and avoid a graveyard of old demos. With basic authentication, you can share work-in-progress safely. For important presentations, keep a backup Scotty server or have your Compose files ready for rapid redeployment.
Continuous CI/CD
For continuous integration, Scotty fits naturally. Deploy every pull request to its own environment, run automated tests against the deployed app, and include the preview URL in pull request comments. Developers see changes in context. Reviewers test functionality without checking out branches. The team collaborates faster.
Internal tooling
Scotty also suits internal tooling that does not require production-grade reliability but should be accessible. Deploy internal dashboards, testing utilities, or dev tools and give the team simple URLs. Lifecycle management provides reasonable uptime expectations without dedicated operations.
Billable hours and developer productivity
For agencies, Scotty converts coordination time into billable development time. Instead of spending 30 minutes explaining a feature over email or setting up a screen share, deploy a preview in seconds and send a link. Senior developers spend less time in meetings and more time building. Faster feedback also reduces back-and-forth based on descriptions or static mockups.
Developer productivity improves by reducing context switching. Rather than pausing to set up staging deployments or coordinate demos, developers stay focused on building. Instant sharing accelerates feedback loops and catches issues earlier, when they are cheaper to fix.
The infrastructure economics
Server costs are modest compared to enterprise alternatives. A basic 50–100 USD per month bare-metal server or VPS can handle 10–20 concurrent applications, depending on resource needs. Many enterprise preview solutions start in the hundreds or thousands per month for similar team sizes. For a five-developer team, the payback period is typically a few weeks when you include saved coordination time.
Because Scotty deploys via Docker Compose, disaster recovery is straightforward. Recreate the server and redeploy in minutes rather than managing a complex Kubernetes cluster. Applications keep minimal state, so traditional backups are rarely necessary. You can redeploy from source code or move to a replacement server quickly. Routine maintenance still applies: security updates, basic monitoring, and occasional scaling decisions. The operational overhead is far lighter than orchestration platforms, with the known trade-off of single-node limits.
Ready to beam up your apps
Full documentation, installation guides, and examples are available at scotty.factorial.io. The source code and contribution guidelines are on GitHub at github.com/factorial-io/scotty.
If you are tired of the friction between “it works on my machine” and “let’s show this to stakeholders”, Scotty offers a simple, focused bridge. Sometimes the most effective solution is the one that does just what you need — and nothing more.