Why Startups Are Building Their MVPs on Top of Proxy Layers

Embracing the Kintsugi of Software: Why Startups Forge MVPs on Proxy Layers

---

The Bamboo Principle: Flexibility Through Proxy Layers

In Japanese tradition, bamboo is revered for its flexibility and resilience. Similarly, startups must sway with the winds of change—pivoting products, iterating rapidly, and integrating with uncertain systems. Building MVPs (Minimum Viable Products) atop proxy layers embodies this bamboo principle, enabling teams to adapt without breaking.

What is a Proxy Layer?

A proxy layer acts as an intermediary between your frontend and backend services, or between your application and third-party APIs. It can be an API gateway (such as Kong, NGINX, or Envoy), a custom reverse proxy, or even a serverless function that mediates requests and responses.

---

The Practical Rationale: Why Proxies for MVPs?

1. Decoupling: The Art of Ma (間)

In Japanese aesthetics, Ma refers to the space between objects—a pause that creates meaning. Proxy layers create Ma between frontend and backend, allowing independent development and evolution.

Benefits:
– Frontend and backend teams work in parallel.
– Easier integration with legacy or third-party APIs.
– Rapid swapping or mocking of services.

Example: Rapid Backend Swapping

Suppose your MVP needs user authentication, but your backend is not ready. Set up a proxy that temporarily mocks authentication endpoints, allowing frontend work to continue undisturbed.

// Node.js Express Proxy Example
const express = require('express');
const proxy = require('http-proxy-middleware');

const app = express();
app.use('/api', proxy.createProxyMiddleware({
  target: 'https://real-backend.com',
  changeOrigin: true,
  onProxyReq: (proxyReq, req, res) => {
    // Mock authentication for MVP
    if (req.path === '/api/auth/login') {
      res.json({ token: 'dummy-token', user: { id: 1, name: 'Sakura' } });
    }
  }
}));
app.listen(3000);

2. API Shape-Shifting: Like Origami

As origami transforms a single sheet into endless forms, a proxy can reshape APIs—rewriting endpoints, aggregating responses, or adding/removing headers.

Use Cases:

• Unifying multiple external APIs into a single interface.
• Rewriting inconsistent third-party API responses for frontend compatibility.
• Adding authentication, rate-limiting, or logging without touching backend code.

Example: Response Transformation

With Kong’s plugins, you can modify API responses on the fly, masking sensitive fields or normalizing data for the client.

---

The Table of Benefits: Proxy Layers vs. Direct Integration

Feature	Proxy Layer Approach	Direct Integration
Development Speed	High (decoupled, mockable)	Medium (tight coupling)
Backend Flexibility	High (swap/mask APIs)	Low (hard to switch)
Security	Centralized control	Scattered, harder to audit
Scaling	Easy (add caching/load balancing)	Harder (per endpoint)
Change Management	Simple (update proxy rules)	Complex (update codebase)
Third-Party Integration	Unified, manageable	Fragmented, inconsistent

---

Step-by-Step: Building an MVP on a Proxy Layer

1. Select Your Proxy

• API Gateway: Kong, AWS API Gateway, NGINX.
• Custom Proxy: Express.js with http-proxy-middleware.

2. Define Endpoints and Mock Data

Embrace the wabi-sabi—the beauty of imperfection. Start with simple, mockable endpoints, refining them as real services mature.

# Kong declarative config example
routes:
  - name: user-login
    paths: ["/api/auth/login"]
    service: mock-auth-service

3. Add Plugins/Logic

• Authentication: Use JWT plugins or insert mock logic.
• Rate Limiting: Add policies at the proxy.
• Transformation: Rewrite requests/responses as needed.

4. Swap and Extend Seamlessly

As real backends solidify, update proxy routes to point to production services instead of mocks, minimizing frontend changes.

---

The Zen of Observability and Security

A proxy layer acts as the kanban—the visible board—centralizing access logs, error tracking, and security policies.

Observability

• Centralized logging: Aggregates all traffic, useful for debugging.
• Metrics plugins: Prometheus integration with Envoy.
• Tracing: Add OpenTracing support easily at the proxy.

Security

• CORS management: Handle cross-origin requests in one place.
• IP whitelisting/blacklisting: Guard your MVP like a temple gate.
• TLS termination: Secure connections without backend complexity.

---

Real-World Examples: Japanese Startups and Beyond

Mercari’s Microservices Evolution

Mercari, one of Japan’s leading marketplaces, famously migrated to a microservices architecture with an Envoy-based API gateway. By layering a proxy, they decoupled rapid frontend iterations from backend service changes—enabling the MVP spirit even at scale.

Early-Stage SaaS: Mocking Payments

A fintech startup can use a proxy to wrap external payment APIs. During MVP, the proxy returns simulated payment responses, allowing user testing without real transactions. Later, swapping to the real payment provider is as simple as changing the proxy target.

---

Further Reading and Resources

• Kong API Gateway Documentation
• Envoy Proxy Documentation
• Microservices with API Gateway Pattern – Microsoft
• Reverse Proxy in Express.js
• Mercari Engineering Blog: Microservices
• OpenTracing Documentation

---

In the spirit of kaizen, let your proxy layer be the quiet guide—enabling small, continuous improvements as your MVP finds its true form.