Skip to content

Platform as a Service (PaaS) Model

The PaaS Contract

PaaS says: "Give us your application code, we'll handle the rest."

The platform manages: - ✅ Infrastructure provisioning - ✅ Operating system updates - ✅ Runtime environments (Ruby, Python, Node, Java, etc.) - ✅ Scaling and load balancing - ✅ Health checking and recovery - ✅ Logging and monitoring

You focus on: - ✅ Application code - ✅ Application configuration - ✅ Data models and schemas

PaaS Abstraction Levels

IaaS (AWS, Azure, GCP) ↓ "Here's a VM" ↓ Kubernetes ↓ "Here's a container orchestrator" ↓ PCF / Cloud Foundry ↓ "Here's your deployed app" ↑ Highest abstraction

Why This Matters

Cost of Lower Abstraction

More control = More decisions = More work:

  • IaaS: 50+ decisions per deployment
  • Kubernetes: 30+ decisions per deployment
  • PCF: 3-5 decisions per deployment

Cost of Higher Abstraction

Less flexibility = Less control:

  • IaaS: Can do anything
  • Kubernetes: Can do almost anything
  • PCF: Can do common things

PaaS Characteristics

1. Application-Centric

Focus on applications, not infrastructure:

```bash

IaaS thinking

"I need 3 c5.xlarge instances in us-west-2a"

Kubernetes thinking

"I need a deployment with 3 replicas of my image"

PCF thinking

"I need to deploy my application" ```

2. Opinionated Defaults

PCF makes good default choices:

Choice Decision Why
Scaling CPU-based autoscaling Works for most apps
Health Liveness checks Self-healing
Config Environment variables Simple, standard
Storage Ephemeral (stateless) Scale horizontally

You can override defaults if needed.

3. Service Integration

Services (databases, caches) integrate seamlessly:

```bash

In IaaS: Manage connection strings, secrets, networking

In Kubernetes: ConfigMaps, Secrets, service discovery

In PCF: Automatic injection via service binding

$ cf bind-service my-app my-database

Done. Your app receives: DATABASE_URL, DB_USER, DB_PASS

```

4. Developer Velocity

Push code, get production:

```bash $ git push heroku main

30 seconds later

$ curl https://my-app.herokuapp.com

✅ Running

```

Trade-Offs: The PaaS Contract

What You Gain

  • 🚀 Developer velocity (days instead of weeks to production)
  • 🎯 Reduced operational complexity
  • 🔄 Faster iteration cycles
  • 🛡️ Built-in security and compliance
  • 📊 Included monitoring and logging

What You Lose

  • 🎛️ Infrastructure customization
  • 📦 Fine-grained control
  • 🔧 Custom container orchestration
  • 💰 Potential cost efficiency (vs IaaS)

When to Choose PaaS (PCF)

Good Fit ✅

  1. Microservices Architecture
  2. Many services need rapid deployment

  3. Service binding matches microservices design

  4. Developer-First Organizations

  5. Team productivity is priority

  6. Less infrastructure expertise available

  7. Internal Developer Platforms

  8. Building platforms for other developers

  9. Abstraction layers provide consistency

  10. SaaS Multi-Tenancy

  11. Need isolation and quota management

  12. Orgs/spaces provide natural boundaries

  13. Rapid Experimentation

  14. New features/products need fast deployment
  15. Overhead must be minimal

Consider Alternatives ⚠️

  1. Highly Custom Infrastructure

  2. IaaS with custom orchestration

  3. Very Cost-Sensitive

  4. Bare metal or IaaS (spot instances)

  5. Specialized Compute

  6. GPU, custom hardware

  7. IaaS gives more options

  8. Full Control Priority

  9. Bare metal or Kubernetes with custom controllers

PCF as PaaS

PCF implements the PaaS model through:

  • Buildpacks: Automatic build and deployment
  • Application model: Simple deployment unit
  • Service brokers: Service integration
  • Routes: Built-in load balancing
  • Orgs/Spaces: Multi-tenancy
  • Quotas/RBAC: Resource and access control

Next: PCF Architecture