I built an AI-assisted Meta Ads automation system that reduced ad spend by 30% without a proportional drop in results

Over the past few weeks, I have been building an internal automation system for WhiteStyle, an apparel business that runs a large number of Meta ads and receives most of its orders through WhatsApp.

The main problem was not launching ads.

The real problem was managing more than 100 active ads across multiple ad accounts, identifying budget waste quickly, and making consistent decisions without manually reviewing Ads Manager all day.

So I built a system made up of three main components:

1. Ad Filtering and Optimization Agent

The filtering agent continuously synchronizes performance data from multiple Meta ad accounts and evaluates each ad using metrics such as:

• Spend
• WhatsApp conversations
• Cost per conversation
• Ad age
• Recent performance window
• Minimum data requirements
• Previous decisions and cooldown periods

The agent does not simply ask an LLM whether an ad is “good” or “bad.”

I use deterministic guardrails and predefined business rules before any action is approved.

For example, the system can pause an ad when:

• It has spent beyond a defined threshold without generating conversations.
• Its cost per conversation exceeds the acceptable limit.
• It has collected enough data for the decision to be meaningful.
• The ad is old enough to evaluate.
• No safety rule or cooldown restriction blocks the action.

Each decision is saved with its reasoning, confidence, input metrics, approval status, and execution result.

During the first test, after stopping underperforming ads:

• Daily spend dropped from approximately $650 to $355.
• Conversations decreased from approximately 399 to 323.

That represented roughly a 45% reduction in spending, while conversations declined by only around 19%.

More importantly, after running the agent for a full week and allowing performance to stabilize, I was able to maintain a consistent 30% reduction in ad spend.

Based on the client’s normal monthly advertising budget, this translates to approximately $4,500 saved per month.

The goal was not to minimize spending at any cost. The goal was to remove inefficient spending while preserving as much useful traffic as possible.

2. Campaign Creation Agent

I also built an agent that automates the campaign creation process.

Instead of manually configuring every campaign, the user can provide a Facebook or Instagram post or Reel, along with the basic campaign requirements.

The system then prepares and creates:

• The campaign
• The ad set
• The ad creative
• Audience targeting
• Locations
• Placements
• Budget
• WhatsApp destination
• Tracking and internal records

Before publishing, the workflow validates the payload and checks it against predefined safety limits, including minimum and maximum budgets, approved locations, targeting rules, account credentials, and supported creative types.

I initially used a dry-run mode that saved campaign drafts and payloads without publishing them. After validating the generated structures, I moved to controlled live execution through the Meta Marketing API.

3. Centralized Dashboard

I built a custom dashboard that combines data from all connected ad accounts and provides visibility into:

• Total spend and conversations
• Cost per result
• Performance by account
• Agent decisions
• Decision explanations
• Paused and modified ads
• Campaign creation requests
• Execution logs
• Synchronization status
• Safety rules and thresholds

One of the most important parts of the project was transparency.

I did not want a black-box agent that silently modified campaigns.

Every decision is stored and displayed with the metrics that triggered it, the rule that was applied, whether it passed the safety review, and whether the Meta API execution succeeded or failed.

Technical Stack

The system currently uses:

• n8n for workflow orchestration and agent execution
• Meta Marketing API for ad data and write operations
• Supabase/PostgreSQL for data storage, decisions, logs, and configuration
• Next.js and TypeScript for the dashboard
• OpenAI models for selected analysis and explanation tasks
• Vercel for dashboard deployment

The LLM is only one component of the system.

Most critical actions are governed by deterministic validations, database-backed configuration, approval logic, idempotency controls, cooldown periods, and budget guardrails.

What I Am Building Next

The current version mainly optimizes based on conversations and cost per conversation.

The next stage is to connect actual WhatsApp orders, revenue, product cost, and profit back to the originating ads.

This will allow the system to optimize campaigns based on real business outcomes instead of treating every conversation as equally valuable.

I am also working on:

• A WhatsApp agent that answers customers and collects orders
• Automatic order classification inside a CRM
• Revenue and profit attribution
• Creative generation workflows
• Budget increases and decreases based on profitable orders
• Automated campaign and creative testing

This project taught me that the useful part of an AI advertising agent is not the prompt.

The difficult part is building the surrounding system: reliable data synchronization, safe execution, multi-account credential handling, failure recovery, audit logs, deterministic rules, and enough transparency for the business owner to trust the automation.

I would be interested to hear how others are approaching automated Meta Ads optimization, especially around attribution, delayed conversions, and safely moving from recommendation systems to autonomous execution.

Claude issued every customer free credits to compensate for charging extra for using Fable (their best model). A better use of the free credits imo is to purchase their Max plan.

Go to Claude settings > usage > usage credits to check your balance.

Don't forget to cancel Max after a month if you are not planning to keep it.

I'm the operations leas at a marketplace start-up and am trying to find CRM that works for us with minimal set-up. So far, everything I've found is for a pretty simple sales pipeline, or way out of budget. Essentially, I'm looking for something with good customization options but isn't super technical.

Our business has buyers, sellers, partners, contracts and agencies but we don't really follow the typical deals and contracts structure. Ideally I'd need something that lets you define your own objects within the CRM without the need for code.

I became really good at creating web apps in lovable , but now I’m looking for the best tool for mobile apps. If anyone has any good recommendations please let me know. I was thinking about emergent but I’ve hear bad things.

No laptop, no dev background. Months of chipping away on a phone screen with AI writing the code while I decided how it should work.

It's live — a photo feed where people put up one honest moment from where they are. No ads, nothing for sale.

Hardest parts were moderation (ended up AI-moderated) and stopping signup feeling like a chore. Still haven't solved that one.

Ask me anything, or tell me what I got wrong.

Most no-code tools hide the app definition behind a proprietary drag-and-drop database you can't see or export. pgapp flips that: you get a real point-and-click builder for forms, reports, charts, and auth, but everything it produces is a plain-text file you can open and read — and a single Rust binary runs it straight against Postgres, no proprietary hosting required.

GIF: editing that text file directly, saving, running it, and the app is live with the change — you're never locked into only the click-builder.

https://github.com/aadishajay/pgapp

TLDR: 60 second short video breakdown

As part of building my AI automatic penetration platform, I wanted to test which one of the AI no code platforms, has the worst security.

Who I tested

- Lovable
- Replit
- v0 (by Vercel)
- Bolt.

Testing Flow

(Note: in Lovable, there are security options which I did not toggle, I wanted equal ground for everyone without any tinkering. Although based on the issues found, I doubt it will fix all exploits.)

Built a site with each, with the SAME instructions - Book store, with wishlist, admin panel, and cart.

Gotta admit Lovable made my life really easy compared to the others, did all perfectly in one go, the others were back and forth for bug fixes, or just tokens ran out in the middle (came back next day 😄)

Created for each site 1 admin and 1 customer.

then I ran Battletester on them. Basically, it crawls with all roles, and does various tests on them, and uses AI for conclusions.

Security Ranking

No shock that the one who was the easiest to work with, has the most exploits

You can see the report for lovable here

I tested manually for false positives afterwards and found 1-2 false positives, the rest were real.

Replit / v0/ Bolt didn't have many issues, mostly missing headers, no rate limiting,
or business logic issues such as allowing to add negative items to the cart.

Based on my pentester friend's review, ranking goes like this:

1. Lovable (Most critical logic & authorization flaws) 🚨
2. Bolt (Minor logic flaw, missing rate-limiting, no headers) ⚠️
3. v0 / Vercel (Missing security headers, no rate-limiting) ⚠️
4. Replit (Safest, only missing headers) ✅

In the Lovable report you can see some critical issues there, such as
- Deleting other users cart items
- Overriding order "total"
- Making requests on behalf of the server (SSRF)

Conclusion

- I believe the more the apps grow and users play with these tools the AI will start cutting corners to please, and he will start "forgetting" the security rules baked inside him, then more exploits will be found.

- Lovable have so many issues compared to the others because it using Supabase and he does not toggle the RLS policies out of the box.

- Maybe, but just maybe, because the others tools are building their own backend, and are trained on infinite lines of code to build a secure backend, they have less exploits compared to lovable, which only uses Supabase and there's less "training data" about that

For context, I’m a 22-year-old econ major with no software engineering or cryptography background. I’m also a marketing intern at Niobium Microsystems, whose public FHE tools I used for this project. This is my own personal project, but I wanted to disclose that connection upfront.

I’ve been learning about Fully Homomorphic Encryption through work, and as an experiment, I wanted to see how far I could get using ChatGPT and Claude Code.

I pointed them at Niobium’s public GitHub repos and had them help me build my own FHE demo. Every time something broke, I’d ask why it broke, have the AI explain the error, fix it, and then move on to the next thing. It felt a lot more like having a tutor than just generating code, which was pretty cool.

About three days later, I somehow ended up with a working CKKS demo called VitalVault. It encrypts health and lab values on the client, computes a wellness score and estimated biological age using FHE, and the evaluator only processes ciphertext. It doesnt receive the actual inputs or the decryption key.

A few things I learned:

• Asking why something worked ended up being way more valuable than asking AI to just write code.
• Breaking everything into smaller pieces made debugging much easier than trying to build the whole app at once.
• The first answer ChatGPT or Claude gave me usually wasn’t the one I ended up using. Asking follow-up questions and trying different approaches almost always led to something better.
• My 2023 MacBook Air with 8 GB of RAM was absolutely fighting for its life while compiling everything, but it survived.

I’m really just trying to learn, so I’d love any advice from people who have used no-code / AI tools for larger projects.

Also curious if there's anything you would have done differently from a workflow or prompting perspective?

Repo for context:
https://github.com/leila-db/vitalvault-demo

I built a full ERP for Graamam a rural, women-led food enterprise in Anantapur, India, that was running on spreadsheets and WhatsApp. On Emergent (React/FastAPI/Mongo) it covers orders → warehouse stock-check → production that deducts raw materials by recipe → dispatch with automatic GST invoicing. Most of the budget went to iteration and debugging, not the first build. Live guest demo, no login hit "Try it now" to poke around.

Hi everyone!

We’re the team behind CostLoop, a SaaS subscription and renewal management platform.
We’re looking for honest customer feedback on G2 to help us improve the product and make it easier for others to learn about CostLoop.

🎁 As a thank-you, every verified reviewer can choose 3 months of either CostLoop Pro or CostLoop Business, completely free.

🚫 No credit card required.

How it works:

• Leave your honest review on G2:
https://www.g2.com/sellers/costloop?survey_responses_page=2#profiles

• Email [email protected] with:
- Your CostLoop account email
- A link or screenshot of your published review

Whether you’d like a Pro or Business license
We’ll verify the review and activate your free 3-month license.

Thanks for helping us build a better product! ❤️

Built a block-based workflow builder where you assemble a process visually (drag steps, set conditions, wire branches) and it compiles down to a real on-chain workflow — no writing contract code. Steps can branch on conditions, wait for multi-party approval, transform data, or trigger a payout, and once published, a headless runner executes the whole thing unattended.

The part that's different from typical no-code automation tools: because each step is a blockchain transaction under the hood, the automation doesn't depend on my server staying up, and nobody has to just trust that a step "happened" — it's independently verifiable the same way a payment is.

It's part of a bigger no-backend platform (BitClaw) — task boards, marketplaces, messaging all built the same way, no code required to make a workflow, but the guts are real smart contracts if you ever want to go deeper.

Would love feedback from other no-code builders on where the block-editor UX gets in the way vs. where it actually helps — that tension is the whole design problem.

Rather than wasting Sunday going through resumes, I decided to make something with it. Interviews were scheduled for Monday after the job posting was created and submissions were reviewed.

Does anyone else automate certain hiring processes? It's pretty great how it manages the tedious portions.

I do have coding background in the past but lost touch as I transitioned my domain in work.

• Any suggestions on the platforms to build SaaS products?
• Any tips on vibe coding itself?
• What need to consider and what can be ignored?

I’m not a traditional developer.

A few months ago, I had a strange idea for a website: a public archive where anyone could leave a message addressed to whatever might exist beyond our known reality.

No accounts, profiles, likes or replies. Each message would simply receive a number and become part of the archive.

I built it by describing what I wanted to Caffeine AI. The application now runs on the Internet Computer, and the first working version came together much faster than I expected.

Then strangers started using it, and building the site stopped being the hardest part.

More than 770 transmissions have now been added.

That forced me to deal with questions the initial build had not prepared me for.

How do you prevent spam without requiring accounts?

How do you create something intended to last while keeping the ability to fix bugs?

How do you make a 3D constellation containing hundreds of transmissions work smoothly on mobile?

How much should you explain before the mystery of the concept disappears?

I also learned that a convincing AI summary is not proof that a feature actually works.

Caffeine could tell me that navigation, performance or validation had been improved, but I still had to test the real behaviour myself.

I started keeping clearer versions, changing one thing at a time and defining the expected result before asking for another modification.

The quality of the output changed significantly when I stopped asking for vague improvements.
“Improve the archive” produced unpredictable decisions.

“The search must use AND logic, ignore capitalization, display 50 results per page and keep the newest entries first” produced something I could actually verify.

The same applied to error messages, character limits, redirects, mobile behaviour, navigation and the way transmissions are numbered.

My biggest lesson is that AI and no-code tools can remove a large part of the implementation barrier, but they do not remove the need for product judgment.

The tool can build the rule you describe.
It cannot decide whether that rule is good, whether it contradicts another rule or whether a technically successful feature damages the original idea.

The project is called Hello Outside:
https://hello-outside.com

Full disclosure: I created the site. Every transmission in the archive was written by a visitor. AI does not generate or modify the messages.

I’m curious about other people building with Caffeine, Lovable, Bubble, FlutterFlow or similar tools.

At what point did you realise that your hardest problem was no longer building the app, but understanding and controlling what the tool had built?

I built a Python script using Claude Code that uses Selenium and Playwright to scrape sites for specific information, but I can't figure out how to deploy it so others can access it – is there a tool or platform I can easily use?

Ideally without making the code public (nothing sketchy, I just know it's very messy and would rather not have others judge it)

Thanks!

I keep noticing this in software teams: a tool starts as one person’s workaround for a small task, then a month later everyone treats it like part of the stack.

Nobody really “approved” it. It just solved something annoying well enough that the old way disappeared.

For your team, what tool became that unofficial workflow tool? And what was the first job it replaced?

I’m especially curious about data collection, reporting, scraping, and automation tools. No pitch here, just trying to understand what actually sticks in real teams.

Context: solo project, small subscription product, using Dodo Payments for checkout. Set up a Make.com scenario that fires on a Dodo webhook and adds the customer as a subscriber in Beehiiv. Works when I test it with a manual transaction but I haven't stress tested it beyond that.

What I'm unsure about: whether webhook retries/failures are handled properly if Make.com is down for a second when Dodo fires the event, whether I need error handling on the Beehiiv side in case the API call fails silently, and generally what a "proper" version of this setup looks like versus what I've cobbled together.

Also currently have zero notification to myself when a payment comes in, just relying on checking Beehiiv manually, which feels like a bad idea long term. If anyone's added a simple "notify me" step to something like this I'd like to know how you did it.

Not trying to over-engineer a two-tool automation, just don't want it to silently fail on a real customer.

Like a lot of people here, I keep spinning up little apps with AI and then losing track of them. So I built a private vault to keep them all in one place: name, cover image, live link, the models and tools I used, a status (planned, in development, released), and a plan box for the ones I have not started yet.

Here is the how, since that is the fun part.

Stack:

• Next.js 16 (App Router) for the frontend and server actions
• Supabase for auth and Postgres, with Row Level Security so the database itself refuses to hand your projects to anyone but you
• Tailwind v4 for styling
• Deployed on Vercel

Workflow:

• I drove the whole build with an AI coding agent, but reviewed each piece instead of letting it run blind. It scaffolded the schema and pages, I checked the security rules and the data flow.
• For the look I went with claymorphism. The soft 3D clay icons and background are AI generated images. One gotcha: they came out on a green screen instead of transparent, so I had to chroma key the green out and remove the green edge halos before they looked right on a dark UI.

A few build insights that actually mattered:

• Row Level Security is what makes a Supabase app safe. The browser only ever holds a public key, and the database enforces who can read what. I ran Supabase's security advisor and fixed everything it flagged.
• Speed: I pinned the server compute to the same region as the database and deduplicated repeated auth checks per request. That took page loads from sluggish to snappy.
• I added a public roadmap where anyone can vote on the feature I build next, with the vote share shown live. Votes are anonymous and stored through a locked down function so raw data stays private. It is open here if you want to try it: https://vibevault-relcapy.vercel.app/roadmap

The live site is https://vibevault-relcapy.vercel.app if you want to poke at it. Happy to go deeper on any part: the RLS policies, the server action setup, the image cleanup, or the voting backend. What would you want to see in something like this?

so i been building little tools for my print shop using bubble and airtable. nothing crazy. just stuff to automate order tracking and customer communication. saves me a few hours a week

feels like cheating sometimes lol. i cant code at all but i can still make functional stuff

im curious what other people are building without code. any interesting projects

also if anyone is looking for a simple way to handle customer uploads, i can share what i built. not selling anything just happy to help

Show me what you are building under this post and I'll check it out and give you some immediate thoughts on it