DEV Community: Erik anderson

The API Key in Your AI-Built App May Be Visible to Every Visitor - Prime Automation Solutions

Erik anderson — Wed, 14 Oct 2026 09:23:26 +0000

The API Key in Your AI-Built App May Be Visible to Every Visitor - Prime Automation Solutions

PRIME AUTOMATIONSOLUTIONS
Menu

  SolutionsBusiness AutomationAI SystemsCustom SoftwareProduction EngineeringNetwork AutomationWebsites
  How We WorkPricingCase StudiesAboutResourcesContact
  Book an Assessment






    Home &gt; Blog &gt; Exposed API Keys

  # The API Key in Your AI-Built App May Be Visible to Every Visitor

  An API key that should stay on the server is shipped inside the browser bundle where any visitor can read it. Here is what to check before real users depend on it.








      October 14, 2026
      &bull;
      6 min read


    ## The complaint behind the search

    People usually search for this after the generated app already looks close: How do I know if my AI-built app is leaking API keys?

    The visible symptom is simple. An API key that should stay on the server is shipped inside the browser bundle where any visitor can read it. The production risk is that the app can look ready while the operating layer is still missing.

    ## What to check before adding features


      Confirm the user, account, or tenant boundary is explicit and tested.
      Confirm secrets, API keys, and webhook tokens are not exposed to browser code.
      Confirm the database rules match the real business workflow, not just the demo path.
      Confirm failures are visible in logs and alerts before a customer reports them.
      Confirm the app has a rollback and recovery path before paid users depend on it.

    ## How PAS turns it into production software

    PAS reviews the generated app, identifies the fragile parts, and adds the production layer around it: deployment discipline, auth review, database rules, payment safety, monitoring, backups, and support ownership.

    The goal is not to rewrite every AI-built app. The goal is to make the risk visible and fix the parts that can hurt the business.


      ### PAS makes AI-built apps production-ready

      Send the app, repo, or public URL. PAS will review the production risks and map the next step: keep it simple, harden it, launch it, or move it into managed engineering support.


        Production readiness checklist
        Review My App
        See PAS Production

PRIME AUTOMATION SOLUTIONSWe build and operate the systems behind the business.

Woodstock · Atlanta · Serving nationally

## Solutions

Business AutomationAI SystemsCustom SoftwareProduction EngineeringNetwork AutomationWebsites
## Work with PAS

Build + Operate pricingAutomation assessmentSend Your App DetailsProduction readiness checklistEngineering toolsService areasGovernment capabilities
## Contact

Email PAS(470) 491-1414PrivacyTermsPAS Websites
© 2026 Prime Automation Solutions · Veteran-owned · Client-specific ownership and services are governed by agreement.

Your Replit App Has a Database. Has Anyone Ever Restored It? - Prime Automation Solutions

Erik anderson — Tue, 13 Oct 2026 14:59:27 +0000

Your Replit App Has a Database. Has Anyone Ever Restored It? - Prime Automation Solutions

PRIME AUTOMATIONSOLUTIONS
Menu

  SolutionsBusiness AutomationAI SystemsCustom SoftwareProduction EngineeringNetwork AutomationWebsites
  How We WorkPricingCase StudiesAboutResourcesContact
  Book an Assessment






    Home &gt; Blog &gt; Replit Database Backups

  # Your Replit App Has a Database. Has Anyone Ever Restored It?

  The app stores real customer records, but nobody has ever restored the database from a backup. Here is what to check before real users depend on it.








      October 13, 2026
      &bull;
      6 min read


    ## The complaint behind the search

    People usually search for this after the generated app already looks close: Does my Replit app need database backups before I launch?

    The visible symptom is simple. The app stores real customer records, but nobody has ever restored the database from a backup. The production risk is that the app can look ready while the operating layer is still missing.

    ## What to check before adding features


      Confirm the user, account, or tenant boundary is explicit and tested.
      Confirm secrets, API keys, and webhook tokens are not exposed to browser code.
      Confirm the database rules match the real business workflow, not just the demo path.
      Confirm failures are visible in logs and alerts before a customer reports them.
      Confirm the app has a rollback and recovery path before paid users depend on it.

    ## How PAS turns it into production software

    PAS reviews the generated app, identifies the fragile parts, and adds the production layer around it: deployment discipline, auth review, database rules, payment safety, monitoring, backups, and support ownership.

    The goal is not to rewrite every AI-built app. The goal is to make the risk visible and fix the parts that can hurt the business.


      ### PAS makes AI-built apps production-ready

      Send the app, repo, or public URL. PAS will review the production risks and map the next step: keep it simple, harden it, launch it, or move it into managed engineering support.


        Production readiness checklist
        Review My App
        See PAS Production

PRIME AUTOMATION SOLUTIONSWe build and operate the systems behind the business.

Woodstock · Atlanta · Serving nationally

## Solutions

Business AutomationAI SystemsCustom SoftwareProduction EngineeringNetwork AutomationWebsites
## Work with PAS

Build + Operate pricingAutomation assessmentSend Your App DetailsProduction readiness checklistEngineering toolsService areasGovernment capabilities
## Contact

Email PAS(470) 491-1414PrivacyTermsPAS Websites
© 2026 Prime Automation Solutions · Veteran-owned · Client-specific ownership and services are governed by agreement.

Before You Hand Customers a Lovable Client Portal, Decide Who Owns It - Prime Automation Solutions

Erik anderson — Fri, 25 Sep 2026 09:23:11 +0000

Before You Hand Customers a Lovable Client Portal, Decide Who Owns It - Prime Automation Solutions

PRIME AUTOMATIONSOLUTIONS
Menu

  SolutionsBusiness AutomationAI SystemsCustom SoftwareProduction EngineeringNetwork AutomationWebsites
  How We WorkPricingCase StudiesAboutResourcesContact
  Book an Assessment






    Home &gt; Blog &gt; Lovable Client Portal Ownership

  # Before You Hand Customers a Lovable Client Portal, Decide Who Owns It

  A client portal generated quickly can become business-critical before anyone owns updates, backups, support, or emergency fixes. Here is what to check before real users depend on it.








      September 25, 2026
      &bull;
      6 min read


    ## The complaint behind the search

    People usually search for this after the generated app already looks close: Can I hand a Lovable client portal to customers yet?

    The visible symptom is simple. A client portal generated quickly can become business-critical before anyone owns updates, backups, support, or emergency fixes. The production risk is that the app can look ready while the operating layer is still missing.

    ## What to check before adding features


      Confirm the user, account, or tenant boundary is explicit and tested.
      Confirm secrets, API keys, and webhook tokens are not exposed to browser code.
      Confirm the database rules match the real business workflow, not just the demo path.
      Confirm failures are visible in logs and alerts before a customer reports them.
      Confirm the app has a rollback and recovery path before paid users depend on it.

    ## How PAS turns it into production software

    PAS reviews the generated app, identifies the fragile parts, and adds the production layer around it: deployment discipline, auth review, database rules, payment safety, monitoring, backups, and support ownership.

    The goal is not to rewrite every AI-built app. The goal is to make the risk visible and fix the parts that can hurt the business.


      ### PAS makes AI-built apps production-ready

      Send the app, repo, or public URL. PAS will review the production risks and map the next step: keep it simple, harden it, launch it, or move it into managed engineering support.


        Production readiness checklist
        Review My Portal
        See PAS Production

PRIME AUTOMATION SOLUTIONSWe build and operate the systems behind the business.

Woodstock · Atlanta · Serving nationally

## Solutions

Business AutomationAI SystemsCustom SoftwareProduction EngineeringNetwork AutomationWebsites
## Work with PAS

Build + Operate pricingAutomation assessmentSend Your App DetailsProduction readiness checklistEngineering toolsService areasGovernment capabilities
## Contact

Email PAS(470) 491-1414PrivacyTermsPAS Websites
© 2026 Prime Automation Solutions · Veteran-owned · Client-specific ownership and services are governed by agreement.

Your Cursor-Built App Needs Logs Before It Needs Another Feature - Prime Automation Solutions

Erik anderson — Wed, 23 Sep 2026 09:23:21 +0000

Your Cursor-Built App Needs Logs Before It Needs Another Feature - Prime Automation Solutions

PRIME AUTOMATIONSOLUTIONS
Menu

  SolutionsBusiness AutomationAI SystemsCustom SoftwareProduction EngineeringNetwork AutomationWebsites
  How We WorkPricingCase StudiesAboutResourcesContact
  Book an Assessment






    Home &gt; Blog &gt; Cursor App Logs

  # Your Cursor-Built App Needs Logs Before It Needs Another Feature

  The generated app can fail silently because errors, background jobs, and form submissions are not wired into searchable logs or alerts. Here is what to check before real users depend on it.








      September 23, 2026
      &bull;
      6 min read


    ## The complaint behind the search

    People usually search for this after the generated app already looks close: Why do users say my AI-built app is broken when I cannot see any errors?

    The visible symptom is simple. The generated app can fail silently because errors, background jobs, and form submissions are not wired into searchable logs or alerts. The production risk is that the app can look ready while the operating layer is still missing.

    ## What to check before adding features


      Confirm the user, account, or tenant boundary is explicit and tested.
      Confirm secrets, API keys, and webhook tokens are not exposed to browser code.
      Confirm the database rules match the real business workflow, not just the demo path.
      Confirm failures are visible in logs and alerts before a customer reports them.
      Confirm the app has a rollback and recovery path before paid users depend on it.

    ## How PAS turns it into production software

    PAS reviews the generated app, identifies the fragile parts, and adds the production layer around it: deployment discipline, auth review, database rules, payment safety, monitoring, backups, and support ownership.

    The goal is not to rewrite every AI-built app. The goal is to make the risk visible and fix the parts that can hurt the business.


      ### PAS makes AI-built apps production-ready

      Send the app, repo, or public URL. PAS will review the production risks and map the next step: keep it simple, harden it, launch it, or move it into managed engineering support.


        Production readiness checklist
        Send Your App Details
        See Managed Engineering

PRIME AUTOMATION SOLUTIONSWe build and operate the systems behind the business.

Woodstock · Atlanta · Serving nationally

## Solutions

Business AutomationAI SystemsCustom SoftwareProduction EngineeringNetwork AutomationWebsites
## Work with PAS

Build + Operate pricingAutomation assessmentSend Your App DetailsProduction readiness checklistEngineering toolsService areasGovernment capabilities
## Contact

Email PAS(470) 491-1414PrivacyTermsPAS Websites
© 2026 Prime Automation Solutions · Veteran-owned · Client-specific ownership and services are governed by agreement.

Moving a Bolt App from Preview to Production Takes More Than a Deploy Button - Prime Automation Solutions

Erik anderson — Mon, 21 Sep 2026 09:23:20 +0000

Moving a Bolt App from Preview to Production Takes More Than a Deploy Button - Prime Automation Solutions

PRIME AUTOMATIONSOLUTIONS
Menu

  SolutionsBusiness AutomationAI SystemsCustom SoftwareProduction EngineeringNetwork AutomationWebsites
  How We WorkPricingCase StudiesAboutResourcesContact
  Book an Assessment






    Home &gt; Blog &gt; Bolt Preview to Production

  # Moving a Bolt App from Preview to Production Takes More Than a Deploy Button

  The app runs in a preview, but there is no durable deployment path, rollback plan, environment separation, or uptime check. Here is what to check before real users depend on it.








      September 21, 2026
      &bull;
      6 min read


    ## The complaint behind the search

    People usually search for this after the generated app already looks close: How do I move a Bolt app from preview to something customers can use?

    The visible symptom is simple. The app runs in a preview, but there is no durable deployment path, rollback plan, environment separation, or uptime check. The production risk is that the app can look ready while the operating layer is still missing.

    ## What to check before adding features


      Confirm the user, account, or tenant boundary is explicit and tested.
      Confirm secrets, API keys, and webhook tokens are not exposed to browser code.
      Confirm the database rules match the real business workflow, not just the demo path.
      Confirm failures are visible in logs and alerts before a customer reports them.
      Confirm the app has a rollback and recovery path before paid users depend on it.

    ## How PAS turns it into production software

    PAS reviews the generated app, identifies the fragile parts, and adds the production layer around it: deployment discipline, auth review, database rules, payment safety, monitoring, backups, and support ownership.

    The goal is not to rewrite every AI-built app. The goal is to make the risk visible and fix the parts that can hurt the business.


      ### PAS makes AI-built apps production-ready

      Send the app, repo, or public URL. PAS will review the production risks and map the next step: keep it simple, harden it, launch it, or move it into managed engineering support.


        Production readiness checklist
        Get a Readiness Review
        Production Support

PRIME AUTOMATION SOLUTIONSWe build and operate the systems behind the business.

Woodstock · Atlanta · Serving nationally

## Solutions

Business AutomationAI SystemsCustom SoftwareProduction EngineeringNetwork AutomationWebsites
## Work with PAS

Build + Operate pricingAutomation assessmentSend Your App DetailsProduction readiness checklistEngineering toolsService areasGovernment capabilities
## Contact

Email PAS(470) 491-1414PrivacyTermsPAS Websites
© 2026 Prime Automation Solutions · Veteran-owned · Client-specific ownership and services are governed by agreement.

A v0 Dashboard Still Needs Permissions Before Real Customer Data - Prime Automation Solutions

Erik anderson — Fri, 18 Sep 2026 09:26:22 +0000

A v0 Dashboard Still Needs Permissions Before Real Customer Data - Prime Automation Solutions

PRIME AUTOMATIONSOLUTIONS
Menu

  SolutionsBusiness AutomationAI SystemsCustom SoftwareProduction EngineeringNetwork AutomationWebsites
  How We WorkPricingCase StudiesAboutResourcesContact
  Book an Assessment






    Home &gt; Blog &gt; v0 Dashboard Permissions

  # A v0 Dashboard Still Needs Permissions Before Real Customer Data

  The generated dashboard looks polished, but admin actions and customer records are not protected by a clear permission model. Here is what to check before real users depend on it.








      September 18, 2026
      &bull;
      6 min read


    ## The complaint behind the search

    People usually search for this after the generated app already looks close: Can I trust a v0-generated dashboard with real customer data?

    The visible symptom is simple. The generated dashboard looks polished, but admin actions and customer records are not protected by a clear permission model. The production risk is that the app can look ready while the operating layer is still missing.

    ## What to check before adding features


      Confirm the user, account, or tenant boundary is explicit and tested.
      Confirm secrets, API keys, and webhook tokens are not exposed to browser code.
      Confirm the database rules match the real business workflow, not just the demo path.
      Confirm failures are visible in logs and alerts before a customer reports them.
      Confirm the app has a rollback and recovery path before paid users depend on it.

    ## How PAS turns it into production software

    PAS reviews the generated app, identifies the fragile parts, and adds the production layer around it: deployment discipline, auth review, database rules, payment safety, monitoring, backups, and support ownership.

    The goal is not to rewrite every AI-built app. The goal is to make the risk visible and fix the parts that can hurt the business.


      ### PAS makes AI-built apps production-ready

      Send the app, repo, or public URL. PAS will review the production risks and map the next step: keep it simple, harden it, launch it, or move it into managed engineering support.


        Production readiness checklist
        Send Your App Details
        $1 Website Launch

PRIME AUTOMATION SOLUTIONSWe build and operate the systems behind the business.

Woodstock · Atlanta · Serving nationally

## Solutions

Business AutomationAI SystemsCustom SoftwareProduction EngineeringNetwork AutomationWebsites
## Work with PAS

Build + Operate pricingAutomation assessmentSend Your App DetailsProduction readiness checklistEngineering toolsService areasGovernment capabilities
## Contact

Email PAS(470) 491-1414PrivacyTermsPAS Websites
© 2026 Prime Automation Solutions · Veteran-owned · Client-specific ownership and services are governed by agreement.

Your Generated App Needs Stripe Webhook Idempotency Before Customers Pay - Prime Automation Solutions

Erik anderson — Sun, 05 Jul 2026 21:12:17 +0000

Your Generated App Needs Stripe Webhook Idempotency Before Customers Pay - Prime Automation Solutions

    Prime Automation







    Home
    Services
    Hosting
    Blog
    Free Tools
    Government
    Free Assessment







    Home &gt; Blog &gt; Stripe Webhook Idempotency

  # Your Generated App Needs Stripe Webhook Idempotency Before Customers Pay

  The app accepts payment, but webhook retries can create duplicate orders, missed fulfillment, or inconsistent account state. Here is what to check before real users depend on it.








      July 5, 2026
      &bull;
      6 min read


    ## The complaint behind the search

    People usually search for this after the generated app already looks close: Why did my generated app create two orders from one Stripe payment?

    The visible symptom is simple. The app accepts payment, but webhook retries can create duplicate orders, missed fulfillment, or inconsistent account state. The production risk is that the app can look ready while the operating layer is still missing.

    ## What to check before adding features


      Confirm the user, account, or tenant boundary is explicit and tested.
      Confirm secrets, API keys, and webhook tokens are not exposed to browser code.
      Confirm the database rules match the real business workflow, not just the demo path.
      Confirm failures are visible in logs and alerts before a customer reports them.
      Confirm the app has a rollback and recovery path before paid users depend on it.

    ## How PAS turns it into production software

    PAS reviews the generated app, identifies the fragile parts, and adds the production layer around it: deployment discipline, auth review, database rules, payment safety, monitoring, backups, and support ownership.

    The goal is not to rewrite every AI-built app. The goal is to make the risk visible and fix the parts that can hurt the business.


      ### PAS makes AI-built apps production-ready

      Send the app, repo, or public URL. PAS will review the production risks and map the next step: keep it simple, harden it, launch it, or move it into managed engineering support.


        Check My App
        See Managed Engineering












        Prime Automation Solutions

      PAS makes AI-built apps production-ready with hosting, auth, payments, monitoring, backups, and managed engineering support.



      Capabilities

        All Capabilities
        AI App Readiness
        Managed Hosting
        $1 Website Launch



      Resources

        Answer Library
        Blog
        Free Tools



      Contact

        erik@primeautomationsolutions.com
        Free Assessment
        Book a Call




    Invisible Systems

    &copy; 2026 Prime Automation Solutions. All rights reserved.

    Atlanta, Georgia

    Licensed, Bonded &amp; Insured.

Your Vibe-Coded App Works in the Demo. Here Are the 12 Things That Break in Production.

Erik anderson — Thu, 02 Jul 2026 22:15:04 +0000

Your AI tool built the app in a weekend. Lovable, Bolt, Cursor, v0, Replit — they are genuinely good at getting from an idea to something that runs. Then you try to put real users on it, and the same handful of things break every single time.

This isn't an "AI code is bad" post. The code is often fine. The problem is that these tools optimize for the demo — the thing that works on your laptop, in one browser tab, with one user (you). Production is a different test: many users, hostile inputs, real money, 2am outages, and nobody watching. That operating layer is the part the generator skips, because it isn't visible in the preview.

Here's the checklist I run on every AI-built app before I'd let real users depend on it. If you built something with one of these tools, go down this list honestly.

1. Secrets in the client bundle

The number one finding. API keys, database URLs, and service tokens end up in the frontend bundle or committed to the repo. Open your deployed app, view source, and search the JS for sk_, key, secret, postgres://. If your Stripe secret key or Supabase service-role key is reachable from a browser, nothing else on this list matters yet — fix that first and rotate the keys.

2. No rate limiting on auth and payment endpoints

Generated apps almost never rate-limit /login, /signup, password reset, or checkout. That's how you wake up to credential-stuffing, thousands of junk signups, or a card-testing attack running through your Stripe account. A basic per-IP limit on the sensitive routes is the minimum.

3. Row-level security that was never actually proven

If you're on Supabase or any multi-tenant Postgres, the demo works because you are the only tenant. RLS policies are easy to write and easy to get subtly wrong. Test it the mean way: log in as user A, grab a record ID that belongs to user B, and request it directly. If you get B's data back, your data boundaries are open.

4. CORS wide open, CSRF missing, weak sessions

Access-Control-Allow-Origin: * on an authenticated API. No CSRF protection on state-changing forms. Session tokens that don't expire or rotate. Each of these is a one-liner to check and a real hole to leave open.

5. No input validation — injection surface

The generated form posts straight to the database or into a template. SQL injection, XSS, and prompt injection (if there's an LLM in the loop) all live here. Every input that reaches a query, a page, or a model needs validation and escaping — not "the ORM probably handles it."

6. No backups, no restore, no rollback

"We have backups" and "we have tested restoring from backups" are different sentences, and only one of them saves you. Plus: when a bad deploy ships, can you roll back in one command, or are you editing production live while users watch? If you don't know, you don't have it.

7. No monitoring, alerting, or on-call

The app is down and you find out because a customer emails you. There's no uptime check, no error tracking, no alert. For an app real people pay for, "I check it sometimes" is not a monitoring strategy.

8. Dependency and supply-chain risk

AI tools pull in a lot of packages fast. Unpinned versions, abandoned libraries, known CVEs sitting in your package.json. Run npm audit (or the equivalent) once and read the output — it's usually sobering.

9. Error handling: the 500 you can't explain

"The contact form sometimes 500s and I have no idea why" is the most common sentence I hear. Unhandled promise rejections, missing try/catch around external calls, no structured logging. When something breaks, can you find out what, or do you just redeploy and hope?

10. Cost-to-scale you haven't modeled

The free tier is fine at 10 users. What happens at 10,000? Unbounded queries, no caching, N+1 database calls, an LLM call on every page load. The app that costs $0 today can cost $4,000/month at modest scale — or fall over entirely.

11. Auth beyond the happy path

Login works. But: password reset, email verification, session expiry, "log out everywhere," account deletion, and what happens when a token is stale. The demo only ever walks the happy path. Users don't.

12. No CI, no staging, no tests

Every change goes straight to production by hand. There's no pipeline, no staging environment, and no test that would catch a regression before your users do. This is the one that turns every future change into a gamble.

None of this means you shouldn't have used the AI tool

You should have. Getting to a working prototype in days instead of months is a real advantage — it's how you find out if the thing is worth building at all. The mistake is treating "it runs" as "it's ready." Those are separated by exactly the list above, and none of it is glamorous work, which is precisely why the generators skip it.

Want a second set of eyes — for free?

I do this for a living (managed hosting plus an on-call engineer for AI-built apps), so I built a free tool for the top of this list. Paste your deployed app's URL or GitHub repo and it runs a safe, automated first-pass snapshot — reachability, HTTPS, redirects, exposed signals, obvious launch blockers:

Free automated snapshot: https://primeautomationsolutions.com/app-readiness-review.html

If you want the deeper version, send a link and I'll send back a one-page audit covering the 12 things above — specific to your app, within 48 hours, no sales call and no drip campaign:

Free production readiness audit: https://primeautomationsolutions.com/production.html

Either way, run the checklist. Your app works on your laptop. The only question that matters is whether it works at 2am when someone you've never met is depending on it.

— Erik, Prime Automation Solutions. Veteran-owned, built in Atlanta. I take vibe-coded apps to production for a living.

Lovable Auth Works in the Demo. Production Is a Different Test. - Prime Automation Solutions

Erik anderson — Sun, 21 Jun 2026 19:46:22 +0000

Lovable Auth Works in the Demo. Production Is a Different Test. - Prime Automation Solutions

    Prime Automation







    Home
    Services
    Hosting
    Blog
    Free Tools
    Government
    Free Assessment







    Home &gt; Blog &gt; Lovable Auth Production Test

  # Lovable Auth Works in the Demo. Production Is a Different Test.

  The generated login flow works in the demo, but tenant data boundaries and row-level security have not been proven. Here is what to check before real users depend on it.








      June 22, 2026
      &bull;
      6 min read


    ## The complaint behind the search

    People usually search for this after the generated app already looks close: Why does my Lovable auth work in the demo but feel unsafe for clients?

    The visible symptom is simple. The generated login flow works in the demo, but tenant data boundaries and row-level security have not been proven. The production risk is that the app can look ready while the operating layer is still missing.

    ## What to check before adding features


      Confirm the user, account, or tenant boundary is explicit and tested.
      Confirm secrets, API keys, and webhook tokens are not exposed to browser code.
      Confirm the database rules match the real business workflow, not just the demo path.
      Confirm failures are visible in logs and alerts before a customer reports them.
      Confirm the app has a rollback and recovery path before paid users depend on it.

    ## How PAS turns it into production software

    PAS reviews the generated app, identifies the fragile parts, and adds the production layer around it: deployment discipline, auth review, database rules, payment safety, monitoring, backups, and support ownership.

    The goal is not to rewrite every AI-built app. The goal is to make the risk visible and fix the parts that can hurt the business.


      ### PAS makes AI-built apps production-ready

      Send the app, repo, or public URL. PAS will review the production risks and map the next step: keep it simple, harden it, launch it, or move it into managed engineering support.


        Review My App
        See PAS Production












        Prime Automation Solutions

      PAS makes AI-built apps production-ready with hosting, auth, payments, monitoring, backups, and managed engineering support.



      Capabilities

        All Capabilities
        AI App Readiness
        Managed Hosting
        $1 Website Launch



      Resources

        Answer Library
        Blog
        Free Tools



      Contact

        erik@primeautomationsolutions.com
        Free Assessment
        Book a Call




    Invisible Systems

    &copy; 2026 Prime Automation Solutions. All rights reserved.

    Atlanta, Georgia

    Licensed, Bonded &amp; Insured.

Build vs Buy: Why We Built Our Own Email Deliverability Monitoring Instead of Paying Postmark - Prime Automation Solutions

Erik anderson — Tue, 12 May 2026 20:59:18 +0000

Build vs Buy: Why We Built Our Own Email Deliverability Monitoring Instead of Paying Postmark - Prime Automation Solutions

    Prime Automation







    Home
    Services
    Network Automation
    Blog
    Case Studies
    Free Tools
    Government
    Free Assessment








    Home &gt; Blog &gt; Build vs Buy: Email Deliverability Monitoring

  # Build vs Buy: Why We Built Our Own Email Deliverability Monitoring Instead of Paying Postmark

  We evaluated five paid tools that range from $0 to $500 a month. Then we built our own. Here is the cost math, the tradeoffs, and what shipped.









      May 12, 2026
      &bull;
      9 min read


    If your business sends email, you have a deliverability problem you probably cannot see. Welcome emails routed to spam. Password resets that never land. Quote attachments that get silently bounced. Marketing replies that go to junk because Google decided your sending reputation slipped last week. None of these show up in your sent folder. They show up as customers who never reply.

    For the last year, we have been operating dozens of sending domains across our hosting customers and our own products. Email is unavoidable infrastructure for any business that hosts a website. So we went shopping for a deliverability monitoring platform. We evaluated five of the obvious choices, did the math, and ended up building our own. This is the writeup.

    ## What "deliverability monitoring" actually means

    Before getting to the tools, the category needs a definition. Deliverability monitoring is not the same thing as sending email. Postmark, Mailgun, SendGrid, SES - those are senders. They put email on the wire. Deliverability monitoring is the layer that tells you what happened next:


      DMARC reports. The XML feedback Google, Microsoft, and other inbox providers send you, telling you which messages claiming to be from your domain actually authenticated correctly. Without parsing these, you cannot tell whether your legitimate mail is aligned or whether someone is spoofing you.
      Bounce and complaint events. Every send produces an outcome - delivered, bounced, marked as spam. Aggregating these per-domain over time is the only way to know if your reputation is sliding.
      Reputation signals from inbox providers. Google Postmaster Tools and Microsoft SNDS publish your domain reputation, IP reputation, and authentication pass rates. You need someone watching the graph.
      Policy enforcement. Are you actually on DMARC quarantine or reject? Or still on monitor-only because nobody pushed the button after warmup?


    A real deliverability platform does all four. A weak one does one or two and calls itself complete.

    ## The vendor landscape we evaluated

    Here is what we looked at, with rough 2026 pricing for a small fleet of sending domains:


      Postmark DMARC Monitor - free tier for basic DMARC report parsing, paid plans for richer analysis. Postmark is best-in-class at sending, but the deliverability monitoring product is a complement, not a full platform.
      dmarcian - $24 to $169 a month depending on report volume and domain count. Strong DMARC analysis. Does not aggregate your bounce or complaint events because it is not a sender.
      EasyDMARC - $39 to $239 a month at the SMB tiers. Cleaner UI than dmarcian. Same fundamental scope - DMARC reports, not full deliverability.
      GlockApps - $59 to $199 a month for inbox placement testing and reputation monitoring. Different angle: they simulate sends to seed addresses across providers and tell you where you landed.
      Mailgun Deliverability - bundled into their sending plans, roughly $35 to $90 a month for the analytics tier. You have to be sending through Mailgun for the data to flow.
      Valimail Monitor - free DMARC parsing, paid for enforcement. Targets enterprise. Sales-led.


    For one sending domain, you can stitch the free or cheapest tiers together for $0 to $50 a month. For a hosting business with a dozen customer domains plus our own product domains, the realistic cost was $200 to $500 a month across two or three vendors - because no single tool covers the whole problem.

    ## Why the math did not work for us

    $200 to $500 a month is not a lot of money in absolute terms. The reason we did not just sign up is that the math gets worse, not better, as we grow.

    Per-domain pricing punishes the customer mix we want. Our hosting customers each have their own sending domain. Every new hosting customer adds a domain to monitor. Vendor pricing scales with domain count, so the more customers we onboard, the more the deliverability bill grows - and the customer is paying us a fixed hosting fee. Margin compresses as we succeed.

    Data we cared about lives in three separate tools. DMARC alignment in one vendor, bounce events in another, inbox placement in a third. To answer a simple question like "did our 9 a.m. quote email get to its recipient and did our sending reputation move because of it," we would need to cross-reference three dashboards. That is operational drag we did not want to design around.

    Custom rules were not on the menu. We wanted to alert on patterns the vendors do not natively detect - for example, a customer's sending domain failing SPF alignment on a specific recipient host while passing on others, or a sudden uptick in soft bounces from a specific ISP that historically signals an impending block. These are queries you write against the raw data, not features you check off in a SaaS UI.

    The data is our customers' data. Our hosting customers trust us with their site, their email, and their business. The DMARC aggregate reports their domains receive belong to them. Routing all of that through a third-party SaaS introduces a data-sharing surface area that is hard to explain in a contract and harder to justify.

    ## What we built instead

    The stack is intentionally boring. Every piece is open source or already in our infrastructure:


      parsedmarc - the open-source DMARC aggregate and forensic report parser. Receives reports via IMAP, parses them, and emits structured records. Maintained, battle-tested, used by thousands of operators.
      AWS SES event destinations - bounce, complaint, delivery, reject, open, and click events fired to SNS, ingested into our metrics pipeline. This is just turning on a feature SES already gives you.
      SQLite for per-domain history - small footprint, no separate database service, full SQL access for ad-hoc queries.
      Prometheus and Grafana - the monitoring stack we already run for everything else. Per-domain dashboards, alerting on bounce rate over 2 percent, complaint rate over 0.1 percent, DMARC fail rate over 5 percent. Same dashboards our infrastructure already lives in.
      A FastAPI service with a few hundred lines of Python tying the above together and exposing an API for our other internal tools.


    Total engineer-time to ship the first useful version: about three working days. Ongoing operational cost: a few cents of disk and a handful of Prometheus scrapes. There is no per-domain pricing, no monthly invoice, no data leaving our infrastructure, and we can write whatever custom alert we want by adding a query.

    ## The honest tradeoff

    We are not telling you that you should build this. We are telling you that we built it because we host websites for other people, and the per-domain economics of paid deliverability tools eat into the margin on a hosting business. Different math for different shops.

    If you send email from one domain and you do not run hosting infrastructure for other businesses, pay Postmark or dmarcian and move on with your day. The free tier of Valimail Monitor or Postmark's DMARC tool will tell you 80 percent of what you need to know, and the paid tiers fill in the rest. Three or four hours of engineering effort is not worth the savings unless you have a structural reason to own the pipeline.

    The structural reasons we had:


      We operate many sending domains, not one. Per-domain pricing is a tax we wanted to remove.
      We already run the monitoring stack the dashboards needed to live in. Grafana was zero marginal cost. For us.
      Our hosting customers' DMARC reports are their data. Keeping it on our infrastructure is a privacy posture we can stand behind in writing.
      We needed custom alerts that the vendors did not expose. Writing SQL against your own database is faster than waiting for a feature request.


    If three or four of those apply to your situation too, building makes sense. If they do not, paying makes sense.

    ## What this means if you host with us

    Every PAS hosting plan now includes email deliverability monitoring on the sending domain attached to your site. DMARC report ingestion, SPF and DKIM alignment tracking, bounce and complaint dashboards, and reputation alerts run quietly in the background. If a problem appears - your reputation slips, a new mail flow starts failing alignment, your bounce rate crosses a threshold - we get the alert and we contact you. You do not need to know the difference between p=none and p=reject. We do.

    This is not a feature we charge extra for. It is part of how a hosting plan should work in 2026. Email is half of your customer relationship. If we are hosting your site, we are watching the deliverability too.

    If you are paying $50 to $500 a month elsewhere for this and not using it, that is a line item worth a second look. See what is included in our hosting, or reach out if you want to talk through your specific deliverability setup before deciding whether to switch.



      ### Want Email Deliverability Monitoring Included With Your Hosting?

      DMARC enforcement, reputation tracking, and bounce dashboards - bundled into every hosting plan, no extra invoice, no third-party tool needed.

      See Hosting Plans













        Prime Automation Solutions

      AI-powered business automation, managed hosting, and network automation consulting. Atlanta, GA. Veteran-owned.



      Capabilities

        All Capabilities
        Managed Hosting
        Network Automation
        Real Estate Automation



      Resources

        Case Studies
        Blog
        Free Assessment



      Contact

        primex001@gmail.com
        Send a Message
        Book a Call




    &copy; 2026 Prime Automation Solutions. All rights reserved.

    Atlanta, Georgia

    Licensed, Bonded &amp; Insured.

How I Built My Own LLM Gateway — Erik Anderson

Erik anderson — Mon, 04 May 2026 15:57:16 +0000

How I Built My Own LLM Gateway — Erik Anderson

Erik Anderson

Free Tools
Buy the Book
Blog
Contact
Get the Free Kit



Tech &amp; Automation
# How I Built My Own LLM Gateway

← Back to Blog

By Erik Anderson
Tag: Tech &amp; Automation
~9 min read

I run sixty-plus active projects through one Claude account. Most of them call Claude on a schedule — a content pipeline at 5 a.m., a trading scanner every fifteen minutes, an email reactor whenever a client writes in, a podcast generator at 7. They don't coordinate with each other. They just fire when their cron tells them to.

The result, predictably, is rate limits. Claude's 5-hour rolling window doesn't care that the contract scanner accidentally went into a retry loop at 3 a.m. and burned the budget the email reactor needed at 9. By the time a client email lands, the account is already saturated. The most important call of the day fails because the least important one already happened.

I tried the obvious things. Cron schedules spread out. Per-project rate limiters in code. A spreadsheet that mapped which scripts ran when. None of it worked, because the problem isn't scheduling — it's that no single piece of software had a global view of the budget. Every script was making local decisions about a global resource.

So I built one piece of software that does. It's called PrimeRouter. This post is what it does, why it's shaped the way it is, and what I'd tell someone thinking about building one.

## The Shape of the Problem

Before the gateway, every service called Claude through a thin wrapper that did one thing: catch a 429, sleep, retry. That wrapper had four failure modes and they all bit me:

No global budget view. Each caller detected rate limits on its own. There was no single place that could say "the account is at 82% of the 5-hour window — stop sending non-critical traffic."
No priority. A speculative blog draft and an in-flight client email got the same shot at the budget. The cheap call won the race more often than the important one.
No provider diversity. When Claude rate-limited, everything just queued behind the wait. I had Codex, Ollama, and a local agentic backend running on a separate machine, and none of it picked up the slack.
No accounting. I had no idea which projects were burning the most tokens until something obviously broke. Post-incident debugging meant reading thirty service logs.

The fix had to live one layer deeper than any individual service. A gateway. Every /opt/ service calls it instead of claude -p directly. The gateway makes the routing, priority, and accounting decisions in one place.

## 13 Priority Tiers

The single most important design choice was that not all calls are equal, and the gateway has to know which is which. PrimeRouter has thirteen priority tiers, declared in a YAML file. They look something like this:

critical — client-facing work that has a human waiting on it (an email reactor handling a client request, a payment-flow webhook).
fixer_attempt_1 through fixer_attempt_3 — auto-fix retries on review-blocked branches. Each retry deliberately routes to a different provider so the model doesn't converge on the same wrong fix three times in a row.
review — code-review and analysis runs.
scheduled — routine pipelines that have a deadline (the morning ScanBrief, the daily podcast).
background — speculative or batchable work (a content draft, a metric refresh).
overnight — anything that can wait until 1 a.m. local time. The scheduler defers these explicitly.

When the global 5-hour budget thins, the gateway closes off the lower tiers first. Critical calls keep getting through. Background calls get a 503-style "try later." Overnight calls get pushed to the actual overnight drain.

This sounds obvious in retrospect. It wasn't obvious at the time. Most rate-limit advice you read on the internet treats every call as equally precious. Mine aren't. The blog post that publishes at 6 a.m. can survive being a few hours late. The email a paying customer sent at 10 a.m. cannot.

"Most rate-limit advice treats every call as equally precious. Mine aren't. The blog post can wait. The customer email can't."

## Multi-Provider Failover

The gateway speaks to four different backends today: Claude (the default for almost everything), Codex over SSH (for code generation when the local sandbox is healthy), Hermes (a local agentic backend running qwen3-coder on an M3 Mac with 70 tokens/sec throughput), and Ollama (small models for mechanical work).

Each tier has a chain — the gateway tries one provider, and if that backend is unavailable or returns a known-bad signal, it falls over to the next. The "known-bad signal" detection took longer to get right than I expected. Codex sandboxes can return exit code zero with a sandbox-failure body in stdout, so a naïve check would record success on a call that actually never ran. The gateway parses for those bodies explicitly and treats them as failures.

The provider diversity also matters because retries on the same model produce the same wrong answer. If a code-review run is blocked because Claude misread the diff, asking Claude again with a slightly different prompt usually doesn't help. Asking Codex or a local model often does. The fixer-attempt chain encodes this — three retries, three different providers, three different reasoning traces.

## Fleet Telemetry

Both my servers run Claude CLI sessions all day. So does my Mac. They all push OpenTelemetry traces to a central collector on the third box, which aggregates token usage across the fleet. The gateway reads from that aggregate.

The reason this matters: Claude's 5-hour budget is per-account, not per-host. A naïve rate limiter on each server would think it had its own budget. The gateway sees one bucket. When the account is at 82%, every host knows it.

The telemetry is also how I answer questions like "which project burned 40% of yesterday's budget" without grepping logs. The dashboard surfaces it directly, broken down by service and call class.

## Per-Workflow Context Injection

Here's where the gateway pays for itself in tokens, not just in priority. Every call carries a workflow field that names what the caller is doing — website_fix, app_change, code_review, knowledge_response. The gateway consults a per-workflow profile that says: for this kind of call, here are the GAMEPLAN sections to inject as system context, here's the tool list to allow, and here's the token budget for the preamble.

A code-review call gets the project's GAMEPLAN, the relevant fix-guides, and an empty tool list (review is read-only). A knowledge call gets a different slice and read-only tools. An app-change call gets the full surface plus write tools. None of them get the kitchen sink.

The byte budget is the part that surprised me. The naïve version of "inject context" is to load every relevant doc into the system prompt — and that's where you find out you've blown 30K tokens before the user's actual prompt is even read. The gateway's context profiles cap the preamble at a configurable byte count and prefer the most-relevant sections within that cap. The cap is observable as a Prometheus histogram, so I can see when it's getting tight.

## What I'd Tell Someone Building One

The article that I think nailed the user-side discipline is Pawel Huryn's Stop Hitting Claude Code Limits — twenty-two concrete techniques for the human at the keyboard. Cache management, model locking, effort tuning, lean tool loading. If you read one piece on this topic, read that one.

The gateway is the layer below those techniques. Everything in Huryn's list is something you do yourself, in your own session, with your own discipline. The gateway is what you build when you have a fleet of services that can't sit at a keyboard and exercise discipline.

The lessons I'd flag if you're building one:

Priority is the foundational decision. Build the tier system before you build the routing logic. If you can't articulate which calls are more important than which, you have no basis for refusing one.
Provider diversity is real, but it's not free. Each backend has its own auth, its own quirks, its own definition of failure. Budget time for the integration.
Telemetry first, decisions second. You cannot make a sane scheduling decision without an aggregated view of usage. Build the telemetry pipe before the scheduler.
Context profiles save more tokens than you'd guess. The prompt isn't the expensive part of a Claude call. The system context you load around the prompt is. Cap it. Profile it. Watch the histogram.
Subprocess isolation is your friend. Each call runs as a fresh claude -p subprocess with model and tools fixed for that invocation. There's no mid-session drift, because there's no mid-session.
Make the failure modes loud. A silent rate-limit drop is worse than a visible 500 — at least the 500 lets the caller decide whether to retry, defer, or escalate.

## What's Next

The gateway is in production and handling thousands of calls per day across the fleet. The next round of work is closing three specific gaps from the Huryn list — disabling 1M-context fallback to save cache writes, passing through Claude's --effort flag so background work can opt down to medium reasoning, and wiring up skill-based model routing so mechanical tasks get a Haiku instead of an Opus. None of those are big diffs. All of them are real money.

The longer-term move is bringing in OpenRouter as a fifth backend so I can route ultra-low-stakes work to GLM-5.1 at roughly a twelfth of Opus cost. And eventually a Tree-sitter-based code-review graph that lets the reviewer load only the functions a diff touches, instead of loading whole files. That's claimed to reduce review tokens by a factor of seven or more. I'm skeptical of the specific number, but the direction is right.

If you're building something similar, I'd love to compare notes. Email me. The full design doc is publicly visible in the project's README — it's the kind of doc I wished I'd been able to read before I started.

The Technical Blueprint
### The Autonomous Engineer — Book 2

The complete guide to running your own automation empire — including infrastructure architecture, AI tooling, monitoring, and the design patterns behind systems like the one in this post.


  Book 2 on Amazon
  Book 1 on Amazon
  Free Starter Kit

← Back to Blog

Why Your Business Automation Needs to Know Which Tasks Matter Most — Prime Automation Solutions

Erik anderson — Mon, 04 May 2026 15:54:25 +0000

Why Your Business Automation Needs to Know Which Tasks Matter Most — Prime Automation Solutions

    Prime Automation







    Home
    Services
    Network Automation
    Blog
    Case Studies
    Free Tools
    Government
    Free Assessment








    Home &gt; Blog &gt; Business Automation Priorities

  # Why Your Business Automation Needs to Know Which Tasks Matter Most

  If every task is equally important, none of them are. Here is what most small businesses get wrong about automation priorities — and the simple fix.









      May 4, 2026
      &bull;
      5 min read


    Most small business automation works fine until the day it doesn't. The day it doesn't is usually the day a real customer reaches out — and the system is too busy doing something less important to respond.

    Here is the pattern I see almost every week. A business sets up a handful of automations. Maybe a content generator runs every morning. Maybe a marketing email goes out on a schedule. Maybe a research task pulls competitor data every few hours. Each one works in isolation. Each one was built without thinking about what happens when they all need to run at the same time.

    Then a customer fills out a contact form during a busy hour. The system that should reply within thirty seconds is in line behind a research task and two scheduled posts. By the time the response actually fires, the lead has already moved on.

    ## The Real Problem Is Not Speed. It Is Priority.

    When people complain that their AI tools are "slow," what they usually mean is "slow on the thing that mattered today." The tools were not actually slow. They were busy doing something less important.

    This is the same problem hospitals solve with triage and air traffic control solves with priority queues. Some things wait. Some things cannot. The system has to know the difference.

    Most off-the-shelf automation tools — Zapier, Make, basic AI integrations — do not understand priority. Every workflow runs in the order it was triggered. A blog post draft and a paying customer's question get the same shot at the queue. The blog post wins more often than it should, because it was scheduled and the customer email was not.

    ## What Priority Looks Like in Practice

    An automation system that knows priority does three things differently from one that does not.

    It tags every task with importance. A customer-facing reply is "critical." A scheduled blog draft is "background." A weekly report is "low." This is not optional. Without tags, the system has no basis for choosing between two tasks that arrive at the same moment.

    It reserves capacity for the important tasks. Even when the system is busy, the critical lane stays open. The way to do this is simple: set a budget for low-priority work, and let the system reject low-priority requests when capacity is tight. Most businesses skip this step and then wonder why urgent tasks fail at the worst possible moment.

    It defers what can be deferred. Reports, drafts, summaries, content generation, scrapes — none of these need to run during business hours. Push them to overnight. The customer email at 11 a.m. should not be competing with a content generator that could just as easily run at 2 a.m.

    ## The Cost of Getting This Wrong

    The math is simple and brutal. Industry data shows that responding to a web lead in thirty seconds versus thirty minutes increases conversion by close to four times. Every minute your automation delays a customer reply, you are losing potential revenue. If your scheduled tasks are blocking customer-facing tasks even occasionally, you are paying a real cost — and you probably do not see it because the failures are silent.

    I have audited small business automation setups where the customer-response system was being delayed by an average of two to four minutes during business hours. The owners had no idea. The dashboards showed everything as "running." The lost leads never showed up as a metric, because the system's idea of success was "did the workflow finish," not "did it finish in time to matter."

    ## How to Fix It

    You do not need to rebuild your automation stack to solve this. You need to do four things, in order.


      List every automation you currently run. Most small businesses have between five and twenty active workflows. Write them down. If you cannot list them, that is the first problem.
      Tag each one as critical, scheduled, or background. Critical means a human is waiting. Scheduled means it has a deadline but no one is actively waiting. Background means it can wait until tomorrow morning if the system is busy.
      Move every background task to overnight. Run them between 1 a.m. and 6 a.m. local. Most are reports, scrapes, drafts, or refreshes — they do not need to compete with customer hours.
      Make sure your critical lane has its own budget. If you are using a paid AI tool with rate limits, reserve at least 30% of your daily quota for customer-facing work. The rest is fair game for the background tasks.


    That is it. No new tools. No expensive rebuild. Just the discipline to admit that not every task in your system is equally important — and to design the system to act like it.

    ## The Test

    Here is a test that will tell you in five minutes whether your automations have a priority problem. Send a fake customer inquiry through your contact form during your busiest hour. Time how long it takes to get a reply. If it is under sixty seconds, your priority structure is fine. If it is over three minutes, you have a priority problem and you are losing leads to it every week.

    The fix is almost always simpler than the diagnosis. The hard part is being willing to look.



      ### Want Us to Audit Your Automations?

      We will look at every workflow you currently run, find the priority gaps, and give you a concrete fix list — whether you implement it yourself or hire us.

      Get Your Free Automation Audit













        Prime Automation Solutions

      Network automation and Dark NOC consulting. We help enterprises eliminate manual network operations with Cisco NSO, Ansible, and Python.



      Services

        Network Automation
        Starter Package
        Growth Package
        Enterprise Package
        Real Estate Automation



      Resources

        Case Studies
        Blog
        Free Audit



      Contact

        primex001@gmail.com
        Send a Message
        Book a Call




    &copy; 2026 Prime Automation Solutions. All rights reserved.

    Atlanta, Georgia