+35%
Campaign rate
PushOwl × Brevo · AI Work
What if your next campaign wrote itself?
AI that writes your campaigns like you would-faster, transparent, and anchored in trust.
AI for Data
AI for Content
AI for Targeting
-18
Minutes saved
3
AI rails shipped
Campaigns that write and target themselves
I shipped three AI rails—Query, Create, Target—so teams experience the finished SQL, copy, and segment before they ever touch the blank state.
- Launched SQL/HTML GPT + AI segments to kill the “I can’t query data” and “I don’t know what to write” blockers.
- Built trust rails with safety checks, inline explanations, and eval loops that reduced support load and time-to-first-send.
Why this work mattered
- Teams were blocked by data access, content creation, and smart targeting.
- Merchants hesitated to start because “I don’t know what to write,” and sometimes even I couldn’t help because “I can’t query data,” or “Whom should I target?”
- My approach: three AI rails - Query → Create → Target. Each rail ships a first win quickly, then deepens.
North‑stars (ranges only): Time‑to‑first‑win ↓ sharply • Adoption moved up in target cohorts • Support questions down on the same paths • Trial → paid improved modestly where AI shipped outcomes early
Custom SQL GPT (internal)
🎯 Goal
Make company data self‑serve for PMs, design, and GTM teams without analyst bottlenecks.
⚠️ Problem
Every data question required back-and-forth with analysts. Teams pasted broken SQL into Metabase. Iteration cycles took days instead of minutes.
🛠️ What I Built
- Schema grounding: Fed GPT clean DDL with table relationships and column types
- Few‑shot library: Seeded ~100 example queries for joins, filters, and cohorts
- Value dictionaries: Exported sample values per column for realistic filters
- Error protocol: GPT asks for context and regenerates failed queries
- Safety rails: Blocks destructive ops, encourages LIMIT for expensive scans
📊 Impact
- Majority of ad‑hoc requests unblocked without analyst help
- Iteration cycles faster (minutes not days)
- Better query quality via value hints and error loops
HTML Email Template GPT (merchant‑facing)
Goal: help merchants create send‑ready HTML emails in minutes.
Problem
Most merchants stall at a blank canvas: writing copy, picking images, linking buttons, product picks, accessibility, responsive HTML.
What I built
- Goal‑aware generation: prompt captures the merchant’s outcome (launch, sale, restock, newsletter).
- Complete outputs: not just text-images (placeholders), alt‑text, CTA URLs, link structure, and responsive blocks.
- Tone/brand controls: Shopify‑merchant tuned tones + language variants.
- Product recommendations: draft related/complementary items from a product URL (heuristic today, API later).
- Customization lane: everything editable; guardrails for accessibility.
Why it’s different
- Outputs send‑ready HTML, not a copy stub.
- Works backward from the goal; proposes sections and subject lines.
- Reduces time‑to‑first‑send dramatically.
Business benefits
Top‑funnel PQLs ↑ • Activation ↑ (first campaign faster) • Retention ↑ (quality + frequency of sends) • Upsell path into higher plans
Current state (hackathon)
Working prototype; pages & help docs drafted; success metrics defined.
Blocked on
- Brevo placeholder syntax for names; dynamic product blocks from Shopify.
Experiments (type‑level)
- “One‑click send‑ready” vs “assistive editor” start → which yields more Day‑1 sends.
- Subject line variants from the same brief → open‑rate lift without over‑fitting.
- Product block variants (grid vs carousel) → click concentration vs breadth.
Impact (ranges)
- Time‑to‑first‑email: significant reduction.
- Template adoption: moved up notably among new users.
- Open/click rates: small but positive deltas in early pilots.
Next
- Domain + UI polish (PushOwl style), move Framer to org.
- Metrics pipeline (installs via UTM, adoption, success events).
- Ads/entry points in email dashboard.
AI Segments (POC; on hold)
Goal: suggest high‑leverage audience segments and forecast expected lift so merchants can send smarter campaigns.
Where we started
- Analyzed past campaign performance (Metabase).
- Compared competitors; mapped marketer goals; chose AI Segments as the wedge.
Scope
- Target merchants with richer data (email merchants; ≥10k customers).
- Daily three segment suggestions aligned to goals or intent (High/Medium/Low).
- Show size, recipe (formula), and estimated revenue for each segment.
- Build with Python first; plan an AI copilot layer for campaigns.
Signals & parameters (examples)
Order status, coupon use, geo, traffic source, customer type, AOV tiers, product performance, behaviors (clicked, added‑to‑cart, revisits), recency & frequency.
Predictive revenue (transparent math)
avg_order_value × expected_transactions × segment_size × conversion_probability (Shown
with assumptions; never over‑claims.)
Why email first (not web push)
More data via Brevo e‑commerce; more mature practitioners; clearer ROI; fits our new launch.
Experiments (type‑level)
- Static templates vs personalized segments from store data → personalization wins.
- Daily “Top 3 segments” vs goal‑based suggestions → higher relevance.
- After a win, nudge to managed help for scaling.
Impact (ranges expected)
- Higher campaign relevance and send frequency where suggested segments are tried.
- Meaningful lift in click/conv for high‑intent cohorts.
- Upsell potential via an add‑on model.
Status
Engineering bandwidth limited in Q2; revisit with design‑first spec in Q3. Wireframe: Whimsical. Colab: data generation & scoring scripts.
Version plan
- V1: AI Copilot suggests campaigns from existing data.
- V2: Holiday/flash‑sale awareness by locale.
- V3: Intent‑aware suggestions (high vs first‑sale).
- V4: Refined segmentation rules (RAG over attributes).
- V5: Multimodal RAG for copy and image suggestions.
Personalized Product Recommendation Engine (UX Enhancer)
Goal: dynamic, personalized product blocks merchants can drop into emails/pages as a premium feature (separate from static HTML GPT outputs).
Why not bundle with HTML GPT?
HTML GPT generates static send‑ready HTML. Recommendations need to be dynamic at open/time of render, so this is a separate module.
Approach (stack‑agnostic)
- Collaborative filtering: “people like this also bought …” using interaction/purchase similarity.
- Content‑based: match on attributes (category, brand, price band, tags) for cold‑start.
- Demographic filters when available and lawful.
- Hybrid: blend store’s Shopify recommendations with our scores; fallbacks when data sparse.
Merchant value
Less manual curation, more relevant cross‑sell/upsell, better CTR/AOV.
Success signals (ranges)
Noticeable lift in click‑through on rec blocks; AOV nudges where cross‑sells appear; higher reuse of dynamic block over static grids.
Experiments (type‑level)
- 1×1 vs 2×2 vs carousel rec formats.
- “Similar items” vs “Bought together” vs “Recently viewed.”
- Price‑band constraints to avoid jarring jumps.
Next
Service spec (API), caching strategy, guardrails for availability/out‑of‑stock, and controls in editor.
AI Image Resizing for Web‑push Campaigns (POC)
Aim: auto‑produce correctly cropped/resized creatives for Android/Desktop/iOS push so merchants don’t juggle three assets.
Problem today
Users upload multiple variants or hand‑crop to fit standards; it’s slow and error‑prone.
Exploration
Tried Cloudinary’s smart‑crop via API to prove value quickly:
https://res.cloudinary.com/demo/image/upload/g_auto,c_crop,w_200,h_200/sample.jpg
Outcome
Feasible UX, but AI crop is paywalled and quality isn’t guaranteed for all product shots. After a day of POC attempts, I paused the project (cost/consistency trade‑off) and documented an alt path: simple ratio presets + safe focal‑point picker.
Success metrics (if revived)
Time saved per campaign, reduction in asset errors, satisfaction on editor flow.
Custom Opt-ins for PushOwl × Brevo
Goal: let merchants spin up branded, multi-channel opt-in moments (push, email, SMS) without engineering help.
Why we needed it
- Stock modals felt off-brand and underperformed on mobile.
- High-intent cohorts churned during compliance steps (double opt-in, consent language).
- Lifecycle marketers wanted a tangible win while AI Segments and rec engines were still incubating.
What I built
- Layout system: modular blocks for hero, incentive, form, countdown, social proof; snaps to storefront themes.
- Channel-aware logic: toggles for email, SMS, and push with per-channel consent copy + data capture.
- Smart triggers: behavior + intent rules (UTM, scroll depth, exit intent) with caps and suppression lists.
- Data plumbing: auto-tag new contacts into AI Segments, sync to Brevo lists, and fire a “Day 0” playbook.
Workflow
- Pick a goal template (drop, pre-order, restock, giveaway).
- Customise brand tokens, imagery, and incentive copy (AI assist optional).
- Choose trigger + channel mix, preview for desktop/mobile, and publish.
Impact (beta ranges)
- +22–31% list growth on participating stores within 30 days.
- 40% lift in multi-step completion when SMS + email were bundled.
- Support tickets about “how do I edit the opt-in?” dropped to near zero.
Launch shape
Ran concierge onboarding for 12 stores, captured before/after metrics, then productized the editor once we had repeatable guardrails. Engineering later hardened the trigger/targeting logic using the same schema from AI Segments.
Common patterns I used
- Outcome‑first prompts (SQL intent, email goal, segment objective).
- Fast‑feedback loops (error protocol, Day‑2 value receipts).
- Trust scaffolding (plain money/copy, visible cancel, safe defaults).
- Measurement by cohort (UTM, order bucket, surface).
- Guardrails (exposure caps, safe sends, governance on data).
Measurement spine
Primary: time‑to‑first‑win, adoption %, shipped outputs (queries run, emails sent, segments used), trial→paid delta.
Quality: refund questions, support tickets / 100 uses, error rate, unsubscribe/spam on first sends.
Cohorts: order bucket × UTM × offer type (self‑serve / managed) × surface (modal, topbar, feature).
Risks I’m owning
- Over‑automation → keep edits and previews first‑class.
- Discount conditioning in PLG pricing → exposure caps + cohort LTV checks.
- Data correctness anxiety → transparent math, sample values, and validation steps.
- Seasonal bias → maintain evergreen variants.