cloudless
by QL4B Team
philosophy technology simplicity bash

Choose Boring Technology (Even When It’s Bash)

Why the most boring solution is often the most powerful

The Excitement Trap

We’re drawn to exciting technology. New frameworks, cutting-edge languages, innovative architectures. The latest thing that promises to solve all our problems.

But here’s what I’ve learned: The most boring solution is often the most powerful.

What Makes Technology “Boring”?

Boring technology is:

  • Old and stable
  • Well-understood
  • Predictable
  • Has fewer moving parts
  • Solves problems directly

Exciting technology is:

  • New and shiny
  • Complex and feature-rich
  • Promises to solve future problems
  • Has many moving parts
  • Solves problems abstractly

The Bash Example

Consider building a simple API that:

  1. Takes HTTP requests
  2. Calls another API
  3. Transforms the response
  4. Returns JSON

Exciting approach:

// Express.js + TypeScript + Zod + Axios + Jest + Docker
import express from 'express';
import { z } from 'zod';
import axios from 'axios';

const app = express();
const schema = z.object({...});

app.get('/api', async (req, res) => {
  const validated = schema.parse(req.query);
  const response = await axios.get(externalApi, { params: validated });
  res.json(transform(response.data));
});

Boring approach:

#!/bin/bash
api_handler() {
    local params="$1"
    curl -s "https://external-api.com/data" -G -d "$params" \
        | jq '.data | map({id, name, status})'
}

The Results

Development time:

  • Exciting: 2 days (setup, dependencies, types, tests)
  • Boring: 20 minutes (write function, test with curl)

Runtime performance:

  • Exciting: 200ms cold start + 50ms execution
  • Boring: 50ms cold start + 20ms execution

Memory usage:

  • Exciting: 128MB baseline + dependencies
  • Boring: 15MB total

Maintenance burden:

  • Exciting: Security updates, dependency management, version conflicts
  • Boring: Stable for years, no dependencies to manage

Why We Avoid Boring

Psychological reasons:

  • Boring doesn’t feel like “real programming”
  • We want to use our skills
  • Boring doesn’t look good on resumes
  • We assume boring can’t scale

Professional reasons:

  • Team expects modern tech stack
  • Hiring assumes certain technologies
  • Industry best practices favor complexity
  • Fear of being seen as outdated

When Boring Wins

Boring technology wins when:

  • The problem is simple
  • Performance matters
  • Reliability is critical
  • Maintenance cost matters
  • You need to ship fast

Most business problems are boring problems.

The Infrastructure Angle

This is why I built infrastructure that makes boring technology first-class:

lambda-shell-runtime - Run bash functions as Lambda APIs http-cli - Simple HTTP client for shell scripts lambda-shell-layers - Common CLI tools as Lambda layers

The goal: Make it as easy to deploy a bash function as a Node.js function.

Real-World Boring Wins

Web scraping:

  • Exciting: Puppeteer + complex orchestration
  • Boring: curl + htmlq + basic parsing

Data transformation:

  • Exciting: Pandas + Jupyter + complex pipeline
  • Boring: jq + awk + shell pipes

API integration:

  • Exciting: SDK + error handling + retry logic
  • Boring: curl + basic error checking

File processing:

  • Exciting: Custom application + framework
  • Boring: Standard Unix tools + shell glue

The Boring Technology Checklist

Before choosing exciting technology, ask:

  1. Can I solve this with standard tools?
  2. Am I adding complexity to solve future problems?
  3. Will this be easier to debug in 6 months?
  4. Can someone else understand this quickly?
  5. What’s the simplest thing that could work?

Embracing Boring

Start boring, upgrade when necessary.

  • Begin with the simplest solution
  • Add complexity only when you hit real limits
  • Measure before optimizing
  • Choose boring for the foundation, exciting for the edges

The Paradox

The most boring choice is often the most innovative.

Using bash for APIs isn’t traditional, but it’s boring technology applied in a new context. The innovation is in the application, not the technology.

Conclusion

Boring technology is a competitive advantage.

While others are debugging framework issues, you’re shipping features. While others are managing dependencies, you’re solving business problems. While others are learning new abstractions, you’re using tools that work.

Choose boring technology. Your future self will thank you.

Part of the cloudless philosophy - infrastructure that gets out of your way.