Week 3 brought in a different kind of challenge: thinking flexibly. I had to work on a system that wasn’t just fast or stable, but adaptable. This meant supporting new platforms (like Supabase), building tools for AI agents, and stress-testing the backend under real-world conditions.

Supabase Migration: From SQL to Flexibility

Migrating from PostgreSQL to Supabase wasn’t just about switching databases — it was about making our backend smarter and more modular. I worked on setting up a dynamic selection layer that let us toggle between the two using environment configs.

What surprised me:

Supabase integrates so much more than just the database — it’s also auth, storage, and an API layer
It felt more opinionated but also more developer-friendly
Having a REST interface and Postgres under the hood gave us the best of both worlds

While I still appreciate the raw power of traditional Postgres, Supabase gave me a taste of how platform-as-a-service can speed up development — especially for full-stack apps or smaller teams.

AI API Interfaces: Building for Agents

Integrating the Model Context Protocol (MCP) server was one of the more conceptual parts of the week. I helped build an interface that lets AI assistants query backend APIs securely, access versioned tools, and retrieve contextual information.

It felt abstract at first, but the more I worked on it, the more I appreciated the vision: enabling AI to act like first-class clients in your API ecosystem. It made me think about API design in a new way — not just for humans, but for intelligent agents too.

Load Testing with Locust: Numbers Don’t Lie

I also implemented Locust for load testing our endpoints. I wrote scripts to simulate things like user signups and item CRUD actions, then monitored how the backend held up.

What I learned:

Latency under load is a very different beast than in local dev
Some endpoints scale well; others degrade fast
Load testing gives you instant feedback on architectural tradeoffs

Honestly, I wish I had done this on personal projects earlier — it’s one of those tools that seems unnecessary until it’s obviously necessary.

Tempo + Loki: Closing the Loop on Observability

We completed the observability stack by adding Tempo (for tracing) and Loki (for log aggregation). Together with Prometheus and Grafana, they gave us full visibility into every part of the request lifecycle.

These tools felt like the glue that connects everything else:

Traces tell the story
Logs tell the details
Metrics tell the trend

Reflections

This week helped me appreciate the balance between flexibility and reliability. Supabase was fast to set up, but required careful integration. MCP introduced new possibilities, but needed guardrails. And tools like Locust and Tempo ensured that what we build doesn’t just work — it holds up.

I’m starting to see backend work less as isolated features and more like building blocks in a living, observable system. And I’m enjoying it.

Week 3 at CyberOni: Rethinking the Stack — Supabase, AI APIs, and Load Testing