Platform as a Service

Welcome! In this blog post we’ll briefly explain what a Platform as a Service is, why we think the current state of the industry is not good enough and needs fixing, and how we’re doing exactly that with Runway, our new offering made by developers for developers.

What is a Platform as a Service?

So when we talk about why we decided to build Runway, we are quick to jump to “Platform as a Service” and then the next question is, “Oh, like Heroku?” and the answer is “yes and no” — so let’s talk about it.

A Platform as a Service (PaaS) lets developers build, deploy, and manage applications without sweating the details of infrastructure. Runway is the simplest, latest and most modern option available but let’s look at the history of the space first: Heroku, which launched in 2007, pioneered this by offering a simple, code-first way to get apps online, using Linux Containers (LXC) under the hood to keep everything isolated and running smoothly.

Around 2010, DotCloud entered the scene with a similar mission but took it a step further by experimenting with containers to support multiple languages and frameworks. This tinkering led to the creation of Docker, a tool that quickly became the go-to for running apps consistently across different environments. In 2013, Docker spun off from DotCloud and changed the game entirely.

Thanks to Heroku and DotCloud’s innovations, PaaS became a developer’s playground, making it easier than ever to bring ideas to life.

In 2014, Amazon (AWS) shook things up by introducing serverless computing with AWS Lambda, also known as Function as a Service (FaaS). Someone must have decided that people were scared of servers, so they coined the term “serverless.” Spoiler alert: there’s no such thing as “serverless”—the servers are still there, just managed by someone else. It’s like shared web hosting with a cooler name.

Serverless is sort of like PaaS, but with a catch: the proprietary tech and the billing model. It looks approachable and super cheap—until you make one mistake or hit a traffic spike, and suddenly your credit card is screaming. The idea is that you can scale up or down in seconds, but be prepared to pay for that flexibility. Want to move elsewhere? — Good luck rebuilding in the next provider’s flavour.

Besides FaaS, the big cloud players—Amazon, Azure, and Google—also offer PaaS-like services that act as a gateway drug to their ecosystems. Take Google App Engine, for example. It fits the PaaS mould but also ropes you into a half-dozen other Google services as soon as you deploy. We’re talking IAM, object storage, registries, instances, networks, routers, and more. If you’re a pro at cloud infrastructure, great—but if not, debugging a problem and deciphering your bill might be a nightmare.

But wait, there’s more!

If trusting someone else with your infrastructure isn’t your style, say hello to Docker Swarm and Kubernetes—the dynamic duo of container orchestration.

These tools (and a few others now extinct) were designed to make a bunch of servers act like one unified system. Whether you’re running them self-hosted on-premise or through a cloud provider, the goal remains the same: deploy your app to a cluster, and let the orchestrator do the heavy lifting. The dream? Your app “just” works, no matter what chaos is happening behind the scenes.

In-house developer platforms are a pipe dream for startups and in the top-3-list of reasons why ideas and companies fail:

1. Product market fit: does anyone want what you’re building?
2. Team: did you assemble the right people for where you are and what you’re building?
3. Execution: shortest path to success with the right tools

Developer platforms fall into the execution category: you select a tech stack and build but you experience complexity and end up building a platform to come out on top — all while your idea isn’t that of building a developer platform but something else.

But let’s get back to Runway—how did we end up here?

When we started building this platform (pre-COVID, which, by the way, was the worst timing ever), we had a solid idea how to address all of the issues of the big platforms mentioned above. But we also realised that a perfect solution would require time, and time-to-market was essential for a bootstrapped organisation like ours.

So we built our first iteration on Docker Swarm. We chose Docker Swarm because it was a well-known and reliable option, allowing our customers to deploy stacks of applications with minimal changes, especially if they were already running on their local machines.

The intricacies of running a Docker cluster could fill another post, but here’s what we learned:

• Apps Need a Lot to Run: A build process, a registry, and more are essential.
• Shared-Nothing Architecture: Sounds easy in theory, but in practice, it’s tough—most frameworks aren’t built for it.
• Visibility and Observability: These are crucial and need to be baked in from the start.
• YAML is Hard: Even though a Docker Compose file is simpler than the mountain of YAML needed for Kubernetes, it still offers plenty of ways to shoot yourself in the foot.

Over the years, we’ve solved many issues for our customers, but this was always meant to be an interim solution. That’s why we circled back to the idea of Runway—to build something even better.

How We Set Ourselves Apart

Runway is focused on tackling the usual pain points of PaaS and minimising the risks for our customers, so you can focus on what really matters—building your app:

• Standard Docker Images: We deploy your app using standard Docker images, ensuring compatibility and flexibility without locking you into proprietary systems.
• Essential Tools: We offer standard tools, like a built-in Postgres database service, so you can deploy seamlessly without worrying about the setup.
• Persistent Volumes: For larger plans, we provide persistent volumes, keeping your data secure and reliable.
• TLS by default: Custom domains, TLS, etc. without diving into what an “ingress” resource is or how to deal with Let’s Encrypt, etc..
• Observability: logs and metrics are first class citizens

We’re just getting started! Our mission is to handle the infrastructure hassles, so you can redirect your time and energy toward creating and refining your app. If you prefer a more hands-on approach, you can always stick with the basics (like a Dockerfile). But, of course, you’ll be missing out on the extra sweetness that Runway adds on top. 😊

PaaS sounds great and all… well, but do you hate (Dev)Ops?

Let’s be honest — it’s not about hate or dislike, but about time and opportunity.

There’s always more work than we can handle. Experience comes at a premium. Just adding AI to the mix is not a recipe for productivity either — so why not focus on what you do best: Building great applications.

We’ve done our fair share of ops-work over the years, but we believe managing machines shouldn’t be the main focus. Often, developers get pulled into “DevOps” not because they love it, but because budget constraints force their hand.

Call us dreamers, but we see DevOps as a way of working—a culture of collaboration. If ops is your passion, this is your evolution—moving away from tools like Terraform, Ansible, or Puppet, and embracing better containers. It’s also a chance to share the gospel of scalability with developers, helping them build more robust and resilient apps.

FIN

The real value of DevOps knowledge lies in making the project move faster: setting up efficient environments, creating rigorous build processes, smoothing out deployments, and optimising pipelines. But when it comes to managing clusters of hardware that might fail? That’s where Runway comes in. We take care of the infrastructure so you can focus on what truly matters—building your idea.

Thanks for reading! We’ll dive deeper into what we’re working on and how our mission is evolving. Feel free to subscribe—yes, we’re old school with an RSS feed, but we got a newsletter as well.