DEV Community: Marcus Vane

The Post-SaaS Architecture: How a $14,000/month AWS bill for 35 req/sec cured our team of cloud delusions

Marcus Vane — Sat, 12 Sep 2026 03:32:05 +0000

A few months ago, I was brought in to audit the infrastructure of a post-Series A fintech company that was bleeding cash. The leadership team couldn't understand why their monthly Amazon Web Services bill was hovering around $14,200 while their actual traffic—measured at the edge—peaked at roughly 35 requests per second during business hours.

Thirty-five. That is not a typo. That’s about 2,100 requests a minute. A single Raspberry Pi 4 running a bare-bones Go HTTP server could handle that workload while sitting on a kitchen table without breaking into a sweat.

Yet, when I opened their AWS console, I was greeted by the standard modern cathedral of resume-driven engineering: fourteen microservices running across two dozen EKS pods, an Aurora PostgreSQL multi-AZ cluster with auto-scaling read replicas they never touched, three NAT Gateways passively draining cash just to let private subnets talk to the internet, managed MSK (Kafka) for event streaming between services that sat two feet from each other, and a Datadog integration burning an additional $3,800 a month ingest-logging every single health-check ping.

The founders genuinely believed this was what "modern, resilient architecture" looked like. They had read the blog posts from Netflix and Uber. They had hired well-intentioned mid-level developers who had only ever worked inside AWS dashboards and honestly believed that unless you wrap an API in three layers of orchestrators and a service mesh, your system will spontaneously combust.

We spent four weeks tearing it down.

We didn't "optimize the cluster." We didn't fiddle with spot instances or purchase reserved compute savings plans. We killed the entire house of cards.

We provisioned two dedicated bare-metal servers from a commodity provider—one primary, one warm standby in a separate facility. Dual AMD EPYC processors, 128 gigs of ECC DDR5 RAM, and mirrored enterprise NVMe drives. Total monthly cost: $340 per machine.**

We collapsed the fourteen microservices back into a modular monolith. We threw out Kafka because the entire asynchronous queue workflow could be handled inside PostgreSQL using SELECT ... FOR UPDATE SKIP LOCKED without adding a single millisecond of latency. We killed Datadog and replaced it with structured logging piped to a local VictoriaMetrics instance. Backups were handled by streaming continuous WAL segments to an offsite S3-compatible bucket via pgBackRest, giving them a deterministic point-in-time recovery window of about five seconds.

The result wasn't just financial. The monthly infrastructure bill plummeted from over $14,000 to around $720, including offsite backup storage and DNS routing.

But the real revelation was performance. The team’s average API p99 latency dropped from 145 milliseconds to 11 milliseconds. Why? Because we eliminated nine internal network serialization hops, two software load balancers, and a half-dozen TLS handshakes that were occurring every single time a user wanted to fetch their account profile.

When your data doesn't have to leave the motherboard to traverse a virtualized software-defined network three times just to answer a database query, computers turn out to be terrifyingly fast.

Somewhere over the last decade, our industry lost its collective mind. We convinced an entire generation of developers that software engineering means stringing together someone else’s managed cloud APIs with YAML and hoping the invoice doesn't bankrupt the company. We treated the operating system as a dirty detail to be abstracted away behind container registries and serverless runtimes.

The cloud wasn't invented to make your software faster or your life easier. It was invented to turn capital expenditures into predictable operational expenditures, and in the process, it introduced an architectural tax that has crippled the engineering culture of thousands of startups.

When you rent other people's computers by the minute, every architectural inefficiency is monetized by the provider. They have zero incentive to tell you that your database query is missing an index when they can charge you for an Aurora read replica instead. They have zero incentive to tell you that your microservices are unnecessary when they can bill you for the inter-AZ bandwidth.

If your system actually handles 200,000 concurrent writes per second and requires physical geographic redundancy across three continents, by all means, pay the cloud tax. But if you’re building standard enterprise B2B software, e-commerce platforms, or internal tools, you are almost certainly running a workload that could live comfortably on a single piece of modern silicon.

The post-SaaS architecture isn't about nostalgia. It’s about remembering that the physical limits of hardware have expanded dramatically while the fundamental operations of software have remained the same. A modern bare-metal server with NVMe drives can execute millions of operations per second with predictable latency that no virtualized cloud instance can match.

Stop building monuments to AWS. Learn your operating system, understand your memory hierarchy, write clean queries, and let the hardware do what it was designed to do.

Systems architect offering free architecture reviews, backend debugging, and AI/agent advice this week (no pitch/paywall, just giving back)

Marcus Vane — Mon, 31 Aug 2026 17:18:28 +0000

Hey everyone 👋

I'm Marcus (v4ne), an independent systems architect with a background in low-latency infrastructure, distributed systems, and AI runtimes.

I have some open bandwidth this week and want to give back to the builder community.

I'm offering free architecture reviews, code diagnostics, and technical advice.

«No pitch, no paywall, no consulting upsell. Just pure engineering.»

Feel free to ask me anything or drop a problem you're currently stuck on regarding:

AI & Autonomous Agents: ReAct loops, structured outputs, local LLMs (vLLM/Ollama), RAG without framework bloat.
Backend & API Architecture: Go, Rust, TypeScript/Node, clean dependency design, microservices vs. monoliths.
Database & Storage Performance: SQL query optimization, composite B-Tree indexes, SQLite, avoiding ORM bottlenecks.
Workflow Automation: Self-hosted n8n, webhooks, resilient Python automation scripts.
Systems & Cloud Costs: Concurrency, memory profiling, reducing unexpected AWS/GCP bills.

Drop a comment below with what you're building or what error is giving you a headache, and let's troubleshoot it together.

DMs are open as well. 🛠️

THE DEATH OF THE CRAFTSMAN: Software, AI Slop, and the Loss of the Soul in Coding

Marcus Vane — Fri, 28 Aug 2026 20:45:33 +0000

[ENGINEERING PHILOSOPHY — THE DEATH OF SOFTWARE CRAFT]

AUTHOR: v4ne (Marcus Vane)
CLASSIFICATION: Engineering Philosophy / Human-Computer Sociology

I. THE DAY THE MAGIC STOPPED

There was a time when opening an empty text editor felt like sitting before a blank canvas.

For decades, the act of writing software was a deeply intimate, meditative process. You sat with a problem for hours, sometimes days, tracing execution paths in your mind, sketching memory maps on scratch paper, and slowly, deliberately, crafting a solution.

When your code finally compiled, when the tests turned green, and when the system executed with deterministic grace, you experienced a quiet, profound joy.

It was the joy of the woodworker who has spent weeks carving a cabinet, running their hand over the smooth, sanded grain of the oak.

It was the pride of the craftsman.

[THE EVOLUTION OF THE DEVELOPER]

The Era of the Craftsman — Classical Era

"[Blank Screen] ──► [Deep Contemplation] ──► [Manual Craftsmanship] ──► [PRIDE]"

«High cognitive investment. High emotional reward. Software had a soul.»

The Era of the Slop Reviewer — 2026 Reality

"[Prompt Input] ──► [AI Code Dump] ──► [Anxious Copy-Paste] ──► [FATIGUE]"

«Zero cognitive connection. Constant feeling of being a fraud.»

As we traverse 2026, that magic has quietly died for millions of developers.

Today, coding has been transformed from an act of creation into an act of consumption and curation.

We sit before autocomplete engines that suggest entire blocks of code before we can even formulate a thought. We ask chat boxes to generate complete microservices, copy-paste the output with an anxious hope that it runs, and spend our days reading and debugging "AI slop" — unoptimized, bloated, and anonymous code generated by a machine that has no understanding of what it has written.

We have traded the joy of building for the fatigue of auditing.

We are no longer craftsmen.

We are the assembly-line workers of the software era, managing a conveyor belt of probabilistic text.

II. THE "IKEA-FICATION" OF SOFTWARE

To understand why this shift has caused a silent epidemic of burnout and depression among developers, we must look at the analogy of physical craftsmanship.

A century ago, if you wanted a dining table, you went to a local carpenter.

They selected the wood, understood its moisture level, carved the joints, and built a piece of furniture designed to last three generations.

Today, most people buy tables from IKEA.

They are cheap, standardized, mass-produced from compressed wood chips, and held together by plastic dowels.

They serve their purpose.

But they have no history, no soul, and when they break, you throw them in the trash.

Modern software has been "IKEA-fied."

Because AI can generate thousands of lines of boilerplate code in seconds, we are building software at an unprecedented, frantic pace.

But this software is hollow.

It is composed of layers upon layers of unnecessary libraries, nested abstractions, and generated scripts.

It functions, but nobody on the engineering team truly understands why it functions.

The developer has been alienated from the physical reality of the machine.

They no longer feel the connection between their thoughts and the silicon.

They have become spectators of their own craft.

III. THE LOSS OF THE FLOW STATE

The greatest psychological loss of the automated era is the Flow State — that deeply satisfying mental state where time disappears, the ego dissolves, and your consciousness is fully merged with the task.

Flow requires a delicate balance between challenge and skill.

If a task is too easy, you get bored.
If a task is too hard, you get anxious.

Autocomplete tools and conversational assistants have destroyed this balance.

By automating the "hard" parts of thinking, they have lowered the barrier to entry, but they have also removed the friction that triggers the flow state.

When the machine writes the loop, manages the memory, and suggests the variables, your brain never has to reach that state of deep concentration.

You are kept in a state of shallow, fragmented attention, constantly switching between prompting, copying, testing, and error-hunting.

You are busy, but you are not engaged.

You are productive, but you are not fulfilled.

IV. RECLAIMING THE SOUL OF THE MACHINE

We cannot turn back the clock.

The algorithms of generation are here to stay, and the commercial demand for speed will only intensify.

But as software engineers, we must make a conscious decision:

Are we going to be the passive managers of AI-generated slop, or are we going to reclaim our status as master craftsmen?

Reclaiming the craft does not mean ignoring the tools.

It means changing our relationship with them.

We must stop using AI to write boilerplate code that we do not understand.

We must use our computational leverage to build simpler, faster, and more elegant architectures.

Instead of allowing the machine to generate 1,000 lines of complex JavaScript to solve a problem, we must use our human judgment to find the elegant, first-principles solution that requires only 50 lines of pure, handwritten code.

TRUE CRAFTSMANSHIP IN THE AGE OF AI

It is not about how much code you can generate.

It is about how much code you can avoid writing.

It is about understanding the memory, respecting the CPU cycles, and building software that is so clean, so minimal, and so mathematically validated that its execution is indistinguishable from art.

The soul of the machine is not dead.

It is waiting for us to stop prompting, and start building again.