DEV Community: Paul Onu

The Curious Case of &num=100: A Beginner-Friendly Guide to Why Your Website Traffic Might Have Dropped

Paul Onu — Fri, 24 Oct 2025 17:46:10 +0000

🕵️‍♀️ The Curious Case of &num=100 — Why Your Website Traffic Suddenly Dropped
A Beginner-Friendly (and Fun) Guide to What Happened to Your SEO Data
“Wait… my impressions are down, my average position looks better, and Google says nothing’s wrong? What the heck is happening?!”
If you’ve been feeling this way since September 2025, you’re not alone. Across SEO dashboards, analytics reports, and marketing chats, people saw massive drops in impressions and assumed their sites were tanking.
But this time, it wasn’t a Google algorithm update or ranking penalty. It was something quieter, geekier, and sneaky: Google finally removed the “&num=100” parameter.
And that tiny bit of text — hidden in URLs — changed how a lot of SEO data works.

WHAT WAS &num=100 ANYWAY?
If you searched something like this:
https://www.google.com/search?q=best+coffee+maker&num=100
That “&num=100” told Google: “Please show me 100 search results at once instead of just 10.”
It was incredibly useful for years:
SEOs could analyze 100 results in one go.

Rank trackers could scrape deeper data.
Analysts could easily count impressions from positions 11–100.

In short, it was a handy shortcut — even if it was never “officially supported” by Google.

WHAT CHANGED
In mid-September 2025, SEO tools and dashboards started acting weird.
Impressions dropped.
Average positions improved.
Rank trackers stopped returning data after position 10.
After a bit of detective work, it turned out Google quietly stopped supporting “&num=100”.
Now, every search request only fetches around 10 results per page, no matter what you append.
Google later confirmed the parameter “is not formally supported.”
Translation: “We told you not to rely on that.”

WHY DID GOOGLE REMOVE IT?
Reduce scraping
SEO bots were fetching 100 results per request — multiplied across millions of queries. Removing it lowers bot load and protects their systems.

Make data more realistic
Most people don’t scroll past the first page of results. Deep “impressions” weren’t representing real user views anyway.

Simplify infrastructure
Smaller, more consistent result batches make Search faster and easier to maintain.

HOW IT AFFECTED YOUR DATA
After the change, everyone’s dashboards freaked out:
Impressions fell sharply (30% to 60%).

Average position suddenly looked better.
Rank trackers lost deep keyword data.
Many thought they were penalized.

But in truth, your traffic didn’t drop. The reporting method changed.
You just stopped seeing “ghost impressions” — results from pages where nobody actually clicked.

REAL-LIFE EXAMPLES
Jane’s Handmade Soap Store
Jane saw her impressions fall from 140K to 90K overnight and panicked.
But most of those impressions were from keywords where she ranked around #70.
Clicks stayed exactly the same — meaning nothing really changed.
Alex’s SEO Agency
Their tracking tool used &num=100 to grab all top 100 results in one request.
Now it has to make 10 requests to get the same data. Costs go up, data depth goes down, and they spent a week calming clients.
Morgan the Marketing Manager
Her boss asked, “Why are impressions down 40%?”
She replied, “Because Google stopped counting results no one ever saw.”
Her boss nodded — and bought her lunch.

WHAT YOU SHOULD DO NOW
Don’t panic about impressions.
They’re just measured differently now. Focus on clicks, CTR, and conversions.

Check your real metrics.
If your actual visits or leads didn’t drop, you’re fine.

Update your dashboards.
Annotate your reports around September 2025 as “num=100 removal.”

Ask your rank-tracking tool what changed.
Some now use paginated fetching to get 100 results again — but it’s slower and more expensive.

WHY THIS IS ACTUALLY GOOD NEWS
The “num=100” removal sounds scary, but it’s actually a cleanup move.
It filters out deep, useless data that no human ever interacted with.
It makes reports more accurate.
It stops SEO teams from obsessing over rankings that never mattered.
Cleaner data = smarter strategy.

🚀 A QUICK WORD FROM POSTLY
If you’re tired of chasing analytics graphs and just want to focus on creating and publishing, Postly has your back.
Postly helps you plan, create, and publish content to all your social media channels — automatically.
From AI writing tools to bulk scheduling, team collaboration, and visual previews, it’s built to save you hours every week.
With Postly, you can:
Schedule months of content in minutes.
Collaborate with your team in real time.
Post to Instagram, LinkedIn, Facebook, TikTok, and more — all from one place.

Keep your brand consistent while staying ahead of trends.
🧠 Less spreadsheet stress. More creative flow.
👉 Learn more at postly.ai

A SIMPLE BEFORE & AFTER SNAPSHOT
Before (&num=100 active):
Impressions: 140,000
Avg. Position: 34
Clicks: 5,100
CTR: 3.6%

After (&num=100 removed):
Impressions: 90,000
Avg. Position: 28
Clicks: 5,000
CTR: 5.5%
The numbers didn’t get worse — they got cleaner.

COMMON QUESTIONS
Q: Should I ignore impressions now?
A: Not ignore — just interpret differently. Look at clicks and CTR first.
Q: Can I still see rankings beyond the top 10?
A: Yes, but tools need to paginate or use APIs — it’s more work.
Q: Did Google do this for AI reasons?
A: Possibly. As AI-generated answers expand, Google wants faster and simpler SERPs.
Q: Is this a rankings drop?
A: No, it’s a data visibility change, not a performance change.

THE TAKEAWAY
The “num=100” saga is a perfect reminder that SEO metrics aren’t gospel — they’re tools, and tools evolve.
When Google changes something this deep, your job is to focus on what doesn’t change: real people seeing, sharing, and talking about your content.
Don’t measure deeper — create smarter.

❤️ FINAL THOUGHTS
Your traffic didn’t vanish — your dashboard just went on a diet.
The &num=100 removal means less noise, more clarity, and cleaner data for everyone.
It’s one of those rare times where less really is more.
And while the SEO world debates data depth, creators and brands using Postly are busy publishing, growing, and building communities that actually see their work.
So keep creating — and let Postly handle the posting part.

SEO isn’t dead - it’s just harder (and ads are getting too expensive).

Paul Onu — Fri, 24 Oct 2025 17:43:36 +0000

For a long time, we poured money into ads - Facebook, Google, even Reddit.
The results? Scanty.
We never had the kind of deep pocket needed to make a deep impact.
So in late August 2025, we decided to try something different.
We started building our own growth engine - powered by code, structure, and patience.
That experiment became our Programmatic SEO (pSEO) journey.

⚙️ How We Built It
We approached SEO like engineers - not marketers.
1️⃣ Free Tools Hub - tools.postly.ai
A growing library of 67+ free tools across media, social, and dev categories.
Each one adds real value - no ads, no gimmicks.
2️⃣ features.json (pSEO)
Each page starts as a JSON entry:
{ url, title, description, category, keywords }

Our script parses that JSON, stores it in MongoDB, and Next.js auto-generates live feature pages - complete with meta tags, JSON-LD, and Open Graph data.
3️⃣ topics.json ([slug] expansion)
This is where things got exciting.
We moved from a handful of pages to hundreds of topic-based pages - all optimized for search intent and automatically linked across categories.

📈 The Results (in less than 2 months)
Average Google position: 47 → 10.8

CTR: 2.5% → 6.7%
Over 272K impressions and 18K clicks in the last 28 days
And “Postly” now shows up more often as a brand keyword

All organic. No paid traffic.
Still early days - but the trajectory feels right.

💡 What I’ve Learned
You don’t need deep pockets to grow.
You just need deep systems.
When you build structured, useful pages that serve people, Google rewards you.
It’s not about chasing algorithms; it’s about respecting intent.

🚀 What’s Live Now
Our new Postly dashboard is live - faster, smarter, and designed for serious creators.
Bulk Post and Postly Cloud are fully live (and have been game changers).
And next up - the Postly API for no-code tools like n8n, Zapier, and Make.
If you haven’t tried Postly yet → https://postly.ai

💬 We stopped spending on ads and started investing in structure.
Still learning, still testing - but this experiment proved something big:
Sustainable growth comes from systems, not spending.
If you’re building something similar, stay consistent.
The compounding effect is real.
🌱 One JSON file at a time.

The Boom, the Bust, and the Quiet Survivors

Paul Onu — Sun, 31 Aug 2025 22:53:00 +0000

The Boom, the Bust, and the Quiet Survivors

Lessons in Enduring Product Marketing Beyond the Hype

When the Sky Lit Up

It was late, and I was wrapping up at Postly’s office when my screen suddenly flooded with ads. Dozens of new AI content tools—bold, polished, imploring you to “Automate your brand”—dominated every scroll and carousel. As a founder who nurtured Postly around scheduling, workflows, and analytics, my heart lurched: Were we about to be swept aside?

That feeling was like standing under a firework display—blinding, overwhelming, thrilling… and terrifying.

A Founder Drowning in Doubt

Internally, I spiraled. I thought: We’re too slow. We’re too small. We’ll be overtaken by these flashy AI newcomers. So I mapped out feature expansions—AI image generators, video editors, even streaming and email marketing modules. Our roadmap became a forest of panic-driven ambitions.

And yet, the world outside—our users—was telling a different story.

Embedded Timeline: Model Milestones & Postly Mood

April 2022 – OpenAI releases DALL·E 2, a leap in realism and usability (Golden). I remember wondering: Should we build an image tool?
October 2023 – OpenAI unveils DALL·E 3, with richer detail and prompt fidelity (TechTarget). The noise intensified; I added more scopes to Postly.
February 2024 – Sora surfaces in demo form: OpenAI’s text-to-video model that can generate minute-long clips (Wikipedia). Panic peaked. I nearly doubled our roadmap overnight.
December 9, 2024 – Sora is publicly launched for ChatGPT Plus/Pro users, delivering 1080p 20-second videos (Reuters). The hype was deafening.
Q2 2025 (around June) – Sora gains broader popularity. Rumors of “Sora 2” emerge mid-2025 (CometAPI). By then, we were already regrouping.

The Surprising Calm Beneath the Noise

Through all that noise, Postly’s numbers didn’t crack.

Onboarding: stable; no mass exodus.
Activity: unchanged—users still scheduling, collaborating, checking analytics.
Support chat offered clarity in stillness:
- “My scheduled Instagram post failed—could you check it?”
- “Can we add another team member to our workspace?”
- “How do I download my last month’s analytics?”

No one asked, “Where’s the AI video feature?” They asked about everyday tasks. That calm blew apart my panic.

When Discipline Shines Brighter Than Hype

Still, fear almost had its way—I almost let Postly become a feature-blotter. Yet instinct held me back. I thought: If we chase every shiny new tool, we’ll lose our identity. Meanwhile, competitors held steady: Buffer didn’t pivot into AI novelty; Publer didn’t either—and they thrived: $2M ARR, then $3M; Buffer quietly scaled past $19M ARR.

They weren’t racing. They were building. That clarity saved us.

Relief in Restraint

Thankfully, those panic-fueled features were never built. Instead, we doubled down on what mattered—scheduling, UX simplicity, and reliability. By early 2025, when the AI video buzz was peaking, Postly stood clean, focused, and resilient.

The Repeat of Patterns

This was not a one-off. It’s a cadence we’ve seen before:

Groupon and daily deals exploded then deflated—merchants burned out, customers moved on.
Scooter startups filled cities before regulation and costs broke the model.
Clubhouse soared during lockdown, then users abandoned it amid competition.
NFTs captivated the world, then collapsed in volume.

Every time, hype dazzles. Then reality reigns.

Theories That Ride Alongside the Story

None of this is random:

Gartner’s Hype Cycle: innovation, inflated expectations, disillusionment, stabilization.
Marketing Myopia: feature hype without deep user understanding fails.
Law of Sh*tty Clickthroughs: ad performance degrades—only retention can sustain.
Diffusion of Innovations: early adopters chase new tech; pragmatists wait for reliable value.

These frameworks don’t overshadow your story—they explain it.

Lessons Etched in Postly’s Journey

Here’s what I’ve learned:

Build hearths—not fireworks. Solve real, daily needs, not novelty.
Identify the glut. When dozens of clones appear, the collapse is near.
Listen to users, not the noise. If no one’s asking, don’t build it.
Be the steady refuge. When hype fades, survivors capture the users left behind.
Trust trumps novelty. Enduring brands stand on discipline and clarity.

A Founder’s Quiet Triumph

That season was one of the most anxious in my career. I was bombarded by doubt. But then our users grounded me. Their steady use of Postly reminded me why we built it: not for headlines, but for consistency, clarity, and trust.

Postly’s survival wasn’t in chasing fireworks. It was in keeping with and protecting the fire.

Final Thoughts

Hype cycles will always come: AI tools, NFTs, Web3, whatever’s next. They light the sky, capture attention, then fade.

But when the night grows quiet, users return to what matters: reliability, trust, and service. That’s where the true survivors build their hearths—not in the pyrotechnics, but in the calm.

Product pricing in a saturated market - the Postly use case

Paul Onu — Wed, 27 Aug 2025 19:16:32 +0000

How We Priced Postly in a Crowded Market

Context. Social scheduling is saturated. We didn’t claim a 10× moat. We needed a price that wouldn’t feel too expensive in a price-sensitive market, wouldn’t look too cheap (and low-quality), and still stayed profitable.

This is the approach we used at Postly in 2025, with real decisions you can copy.

The Simple Framework We Used

Cost → Value → Anchors

Cost Floor (Unit Economics)

Know your cost per unit of value and don’t go below it.
Value Metric (“Enough” Usage)

Define what “enough content” means for a typical customer per unit (e.g., per channel per month), and ensure the base plan covers it comfortably.
Market Anchors

Be legible next to per-channel and bundle competitors without inheriting their pricing psychology.

1) Cost Floor: Build Your CPU (Cost Per Unit)

At Postly, our unit is one active social channel.

CPU = Infra & Ops per channel
    + Support per channel
    + Data & Analytics per channel
    + Compliance & Reviews per channel
    + Payments & Risk per channel

Notes we found helpful

Use P95 usage, not rosy averages.
Allocate support by workload (tickets/time), not just headcount/ARR.
Include failed payments, refunds, chargebacks.
Recalculate quarterly; platforms and cloud costs change.

Your price must sit comfortably above CPU to leave margin for growth.

2) Value Metric: Define “Enough Content”

Customers buy outcomes (a consistent presence), not feature lists. We set an internal baseline of “enough content per channel per month” that typical creators/SMBs/teams should achieve without hacks on the base tier.

If base plans don’t support “enough,” pricing feels unfair.

We keep advanced publishing power separate as an add-on so the base remains simple and predictable.

3) Market Anchors: Be Legible, Not Led

You’ll face two buyer lenses:

Per-channel pricing (clean, often perceived as premium)
Bundles/sets (look cheaper per channel at scale, fuzzier for small teams)

Our rule: price from CPU and value truth, not from a competitor’s brand premium. Stay understandable under both lenses; don’t replicate their baggage.

What We Chose at Postly (and Why)

Base pricing (per channel): $3 Basic / $7 Team
- Transparent, easy to forecast
- Supports “enough content” for typical users
Power as a modular add-on: X-Pro Advanced Publishing (threads, polls, tagging, pacing, etc.) is separate from base
Operational reliability in base: Bulk via CSV, Google Sheets (coming soon), reliable recurring, RSS syndication

Why this worked for us

Clear against per-channel brands without wearing a “premium-price” halo
Avoids bundle optics while staying profitable against CPU
Lets power users self-select into X-Pro without bloating base tiers

Browse the public, pricing-only comparison we maintain:

https://postly.ai/resources/compare-postly

Messaging That Avoided “Too Cheap” vs “Too Expensive”

Name the promise: “Premium publishing. Simple per-channel pricing.”
Anchor to outcomes: “Designed to support consistent posting—no bundle calculus.”
Draw a clear add-on boundary: “X-Pro is advanced control; base stays simple.”
Stay neutral about competitors’ models (don’t sell their benefits for them).
Use round numbers with a story: $3 for creators, $7 for teams—backed by CPU and “enough content.”

Microcopy we used

“Per channel, per month. No bundles, no surprises.”
“Base tiers comfortably support your day-to-day publishing.”
“Add X-Pro when you need advanced controls.”

The Worksheet We Actually Used (Copy/Paste)

Unit Economics

Infra & ops / channel: $___
Support / channel: $___
Data & analytics / channel: $___
Compliance & reviews / channel: $___
Payments & risk / channel: $___ CPU (floor): $___

Value Definition (“Enough Content”)

Typical customer needs ___ posts/channel/month
Base tier comfortably supports ___ posts/channel/month

Market Anchors

Per-channel peers range we’re comfortable with: $–$
Bundle peers: effective per-channel at 5/10/25/50 channels

Our Structure

Base per-channel price(s): $___ (Basic), $___ (Team)
Add-ons: Name → Promise → $___
Volume rules (if any): ___

Guardrails

Target gross margin ≥ ___%
Payback period ≤ ___ months
Support load ≤ ___ tickets per 100 channels

Validation We Ran (Fast & Founder-Friendly)

Van Westendorp (PSM): “too cheap/cheap/expensive/too expensive” thresholds
Gabor-Granger: “Would you buy at $X?” over a small set of price points
Two-cell landing tests: $A vs $B, measuring free→paid, early retention, support load (not just CTR)

Common Traps We Avoided

Pricing straight from a competitor’s page
“Unlimited” base tiers (a few edge users nuke margins)
Feature-packed base plans that muddle the value story
Opaque bundles that increase confusion and churn

Closing

In a saturated market without a clear moat, clarity, fairness, and margin discipline win:

Build a cost floor you won’t cross
Define “enough content” and ensure base plans truly cover it
Keep pricing simple per-unit and modular for power

That’s how we priced Postly: $3 (Basic) / $7 (Team) per channel for clear, everyday publishing—X-Pro as a separate add-on for advanced control. Clear to buyers, durable for the business.

Lessons from Thousands of Hours Building the Postly Website: Rebuilds, AI Magic, and SEO Wins 🚀

Paul Onu — Tue, 26 Aug 2025 21:52:02 +0000

Hey there, creators, dreamers, and digital trailblazers! 🎉
This is the chaotic, hilarious, and downright obsessive tale of how I built the Postly.ai website through thousands of hours of rebuilds, countless late-night coding binges, and a sprinkle of AI wizardry. 😎
This isn’t just a story; it’s a masterclass in grit, pivots, and why your website is your digital handshake. Here are the lessons I learned while turning Postly.ai into a social media automation powerhouse.

Lesson 1: WordPress Dreams Can Turn Into Nightmares 😱
The Start: I kicked off Postly.ai on WordPress, thinking it was the golden ticket. I hired a builder, poured in hours adding content, and dreamed of a slick site.
The Reality: Plugins turned my site into a crash-happy mess. Downtime? Constant. Frustration? Through the roof. 😩 I rebuilt the site 10+ times just to keep it alive.
👉 Takeaway: Sometimes, the “easy” path (like WordPress) is a trap. Test your tools early, and don’t be afraid to ditch what doesn’t scale.

Lesson 2: Big Promises, Bigger Disappointments 💸
The Designer Saga: Desperate for a glow-up, I hired a designer who charged $5,714 USD for a website and dashboard in AngularJS. The designs? Beautiful logos and sleek screens that screamed “pro.” The code? Nonexistent. 🤦‍♂️
My Pivot: After that flop, I salvaged the visuals and enrolled myself in YouTube University. 📺 Learned Next.js, grabbed a GitHub template, and rebuilt the site 15+ times. Here’s the kicker: I realized I didn’t even need those fancy designs.
👉 Takeaway: Trust actions, not promises. And don’t underestimate your ability to learn - YouTube and GitHub are your best cofounders when cash is tight.

Lesson 3: AI Changed Everything (and Saved My Sanity) 🤖
The Turning Point: After 20 more rebuilds (yes, I’m that obsessive), generative AI rolled in like a superhero. Suddenly, I could:
Dream up new layouts overnight.
Tweak and generate code with less stress.
Prototype features faster than ever.

The Result: Postly.ai became sleek, user-friendly, and scalable. I carried the same mindset over to HeyOnu.com. Between both products, I’ve published nearly 400 blog posts (and counting).
👉 Takeaway: AI is like a creative genie. Your imagination is the only limit now.

Lesson 4: Excellence Is Your Secret Weapon When Cash Is Tight 💪
I’ve always told my team: when you don’t have deep pockets for ads, you must excel at everything you can control - product, website, and brand.
Your Website = Your Handshake: I treat Postly.ai like a face-to-face chat. I proactively imagine what users would ask me in a demo, then make sure the website answers it.
Obsess Over Details: From lightning-fast page speed to intuitive flows, every pixel matters.
Content Is King: I don’t just write blogs for filler. I listen, observe, and pick topics users care about right now. That discipline led to hundreds of posts fueling organic growth.

👉 Takeaway: Excellence compounds. No ad budget? Then let your product, website, and words be your best salespeople.

Lesson 5: SEO Is a Game You Can Win 📈
SEO is where all those late nights started to shine.
The Numbers:
Postly.ai: 120,000 impressions/month | 3,000 clicks (2.5% CTR)
blog.postly.ai: 275,000 impressions/month | 2,000 clicks (0.73% CTR)
Total: 395,000 impressions | 5,000 clicks/month

How We Compare:
The industry average for mid-tier SaaS websites is ~30k impressions/month.
The median blog traffic is ~3,930 sessions/month.
We’re well ahead, ranking for competitive terms like social media scheduler and AI content creation.

CTR Insights:
Postly.ai’s 2.5% is 🔥.
The blog’s 0.73% is solid but has room to grow (meta descriptions, I’m looking at you 👀).

👉 Takeaway: SEO isn’t magic - it’s consistent code optimization, metadata discipline, and fresh, relevant content.

Bonus: A Peek at Our SEO Setup 🧑‍💻
We keep SEO lean and organized with a dedicated SiteMetaData.jsx file that powers all pages. Each entry has:
Titles & descriptions
Canonical URLs
OpenGraph + Twitter card previews
Curated keyword tags

Examples:
Home Page: Postly | Social Media Scheduler with AI Automation (tags include “AI content creation,” “multi-platform publishing,” “social media automation”)
Login Page: Optimized for “Postly login,” “social media tool login”
Pricing Page: Optimized for “Postly pricing plans,” “social media scheduler cost”

This keeps the site fast, crawlable, and always SEO-ready.

Final Lesson: Keep Building, Keep Learning 🛠️
After thousands of hours of rebuilds, one truth stands out: your website is never “done.” It’s a living, breathing reflection of your brand.
Stay curious. Embrace AI. Obsess over user experience. Treat your website like your first handshake - it’s the one thing users will always remember.
💬 Got a website war story of your own? Drop it in the comments - I’d love to hear it.

Happy building, and may your bugs be few!

Paul, Postly Founder

From X (Twitter) Free API to Basic/Pro: How Postly Retired BYO Keys and Shipped a Managed “X-Pro” Integration (No Fallback)

Paul Onu — Tue, 26 Aug 2025 18:18:09 +0000

From Free Keys to X-Pro: Why Postly Is Moving to Twitter’s Paid API (and What You’ll Get)

TL;DR — We’re upgrading Twitter/X publishing inside Postly to a new X-Pro Add-On. That means moving from “bring-your-own free keys” to the official Twitter/X Basic → Pro API path managed by us. In return, you’ll get reliability, unlimited monthly posting (with fair-use), Automations, Engagement tools, AI Inspiration, and deeper Analytics—all purpose-built for serious creators and teams.

Why we’re moving away from free keys

If you’ve ever wrestled with Twitter’s old free API flow, you know the pain:

Manual app setup (callback URLs, permissions, tokens)
Inconsistent reliability and sudden rate-limit surprises
Basic posting only; strict caps (e.g., ~100 posts/replies/day/account)
Poor support for advanced use cases (threads, delays, automations, etc.)

That model was OK for early experiments, but it held back creators and teams who need real throughput and automation. The paid API unlocks stability, performance, and feature depth. We’ll manage the sourcing, quotas, and upgrades centrally so you can focus on content and outcomes.

Meet the X-Pro Add-On (Advanced Twitter Module)

Design preview: https://postly.ai/dashboard-design/x-pro

API costs reference: https://docs.x.com/x-api/introduction

The X-Pro add-on is a premium Twitter/X publishing and engagement layer for Postly. It ships with five pillars:

✅ Basic Publishing

Publish Tweets
Auto-Threads
Polls
Alt text for media
Long tweet format (for Twitter Premium users)
Auto-numbering for threads
Tagging
Community posts
- Post with a community hashtag (e.g., #buildinpublic)
- Try to validate via Community ID/name (not in public API yet). If validation isn’t possible, we’ll fallback to hashtag only and show: “Community not validated via API, posting with hashtag only.”

✅ Automations

Auto Retweet — Retweet your own tweets automatically after set delays (e.g., 1h, 6h, 24h), with repeat and auto-stop controls.
Cross-Post to Bluesky — Mirror tweets (text, images, links) to Bluesky.
Schedule Replies — Plan replies under your tweets/threads for campaigns and conversations.
Delay Threaded Tweets — Control pacing between tweets in a thread.
Auto Delete — Automatically remove tweets after a set time (immediate, 24h, 7d, or custom rules).
Auto Plug — Auto-post a first comment under your tweet (text, links, or media).
Tweet → Carousel — Turn tweets into images and repurpose as carousels for LinkedIn, Instagram, Facebook.
Automatic Reposting of Best Tweets — Detect high performers (likes, retweets, replies, CTR) and re-post to extend reach.

🤖 AI Inspiration

Browse Ideas → Select → Rewrite with AI → Publish or Schedule
AI Tweet Writer — Generate viral-style tweets.
AI Thread Writer — Create structured threads around topics.
AI Content Strategist — Recommend themes, hashtags, and formats.
Tweet Inspirations — Explore viral tweets across niches and rewrite with AI.
Viral Thread Hooks — A library of high-impact opening lines.
Tweet Templates — Fill-in-the-blank structures.
Your Best Tweets — Surface your historical top performers.

💬 Engagement

Engagement Builder — Track unlimited users & up to 50 keywords; surface new tweets for quick engagement.
Social Hub — A curated feed of niche-relevant posts with one-click engagement.
Top Followers & Interactions — Identify your most engaged followers and monitor activity.
Auto Comment System — Rule-based comments under your own or others’ posts.

📊 Analytics

Account analytics & posting streaks — Track activity and consistency.
Unlimited analytics timeframe — Store and display lifetime data (not just 30 days).
Post-level stats — Likes, retweets, replies, CTR.
Follower growth & profile clicks
Filter top tweets — Find what works, fast.
Optional public analytics profile — Share your metrics with your audience.

Plans, Billing & Availability

Twitter/X publishing inside core Postly plans is not sold per channel. It’s available exclusively via the X-Pro add-on.

Free — Twitter/X: Not available
LTD — Twitter/X: Not available
Basic — Twitter/X: Not available
Team — Twitter/X: Not available
X-Pro (Add-On) — $30/month per Twitter account
- or $288/year (20% discount)
- Unlimited posts/month per account
- Fair usage applies: soft cap of 500 posts/account/month (contact support if you need more)

Per-account billing: Limits and billing are scoped per connected Twitter account, not per workspace or brand.

API Plan & Roadmap

We are removing the legacy Free API “bring your own keys” connection and moving to Twitter/X Basic (paid by Postly). As adoption grows, we’ll graduate to Twitter/X Pro to unlock significantly higher throughput.

Basic (~15,000 posts/month total across all accounts)
Pro (~1,000,000 posts/month total across all accounts)

We’ll manage the upgrades and capacity planning so your campaigns keep moving.

Fair Usage Policy (Engineering Summary)

This is internal guidance on how we enforce limits; we won’t display these numbers publicly in the app.

Provider Limit (Basic API):
- 15,000 posts/month total across all connected accounts
- Per-account hard cap: 500 posts/month (cannot be exceeded at API level)
Enforcement Logic:
- Track monthly posting counts per Twitter account
- Default soft cap = 500 posts/account/month
- If a user exceeds 500:
- Block further posts for that account until reset, or
- Show: “Posting limit reached for this account. Please contact support.”
Escalation Path:
- As we migrate from Basic ($200, 15k posts total) to Pro ($5k, 1M posts total), support can review accounts and lift limits as capacity increases.
Data Model (suggested):
- Store counters in DB: { account_id, month, posts_count }
- Reset monthly (UTC)
- Flag accounts at 80% of cap (≥400) for monitoring

Rollout Timeline

We’re shipping this alongside the new Postly dashboard rolling out over the next couple of weeks. Early access will open first, then we’ll expand to the full waitlist.

What you’ll notice immediately

No more DIY key management — We handle the API plan so you don’t have to.
Higher reliability — Fewer failed posts and clearer error handling.
More power — Automations, AI workflows, engagement tools, and analytics all tied together.
Scalability — When you’re ready for more volume, we’ll lift the ceiling with Pro.

Frequently Asked Questions

Do I need to re-connect my Twitter account?

A short re-auth may be required during the migration so we can move you to the managed connection. We’ll keep it simple.

Will my scheduled posts be affected?

We’ll aim for a seamless handover. If any action is required, we’ll notify you well in advance inside the app.

Can I still use my own keys?

No. We’re removing the free BYO-keys path to prevent instability and unlock new features that require our managed API.

What if I need more than 500 posts/account/month?

Reach out to support. As we migrate from Basic to Pro, we’ll be able to expand limits for qualified accounts.

Final Thoughts

This shift is about reliability and reach. The free pipeline forced trade-offs that limited your growth. With X-Pro we’re investing in a durable, feature-rich Twitter/X layer—so you can focus on shipping content, not fighting the API.

If you want to be part of the early access, keep an eye on announcements inside Postly. We can’t wait to see what you’ll build.

From “Just Show Local Prices” to a Robust, Auditable Currency System in Next.js

Paul Onu — Tue, 26 Aug 2025 11:06:35 +0000

A practical, learner-friendly walkthrough you can ship (with detection, normalization, multi-provider FX, caching, and a tiny Switch Currency UI)
I’m not a currency or i18n expert - just a builder sharing exactly what worked for me, what broke, and how I patched it while fixing pricing pages for Postly and Onu in NextJs. If you want your pricing page to feel local and behave reliably in production, this is for you.

TL;DR

Detect a sensible default currency via timezone → country → currency (privacy-friendly, no IP geo).
Normalize legacy codes in your static lists (e.g., MAF → MAD, FRF/DEM/ESP → EUR).
Build a multi-provider FX fallback in a Next.js route: exchangerate.host → open.er-api.com → jsDelivr (fawazahmed0) → last-resort fallback.
Add CDN caching (12h) + session cache (6h) and minimal logs (client + server) for sanity.
Render prices with Intl.NumberFormat; use symbol fallbacks where needed.
Include a compact, accessible “Switch currency” button that auto-refreshes.
For checkout integrity, snapshot the applied FX rate into your order record.

Why this matters (even for small teams)

“Show local prices” sounds trivial—until you meet:
Legacy ISO codes in country lists (Morocco’s MAF showed up in my data; modern code is MAD).
Provider churn (an endpoint you used yesterday starts demanding an API key).
Hydration & SSR quirks (flicker vs. gating while detecting currency).
Auditability (what rate did we use at the time of purchase?).
User agency (let them switch if you guessed wrong).
Treat this as a minimum viable reliability pattern you can adapt.

Design goals

Respectful detection: No IP lookups. Use timezone → country → currency.
Graceful degradation: If one provider fails, try another, then fall back.
Predictable UX: Cache rates and format consistently.
User control: A small, unobtrusive “Switch currency” widget.
Auditable: Make it easy to snapshot the rate used at checkout.

Architecture at a glance

Client (useCurrency hook)
  ├─ Reads cookie override (if set by user switcher)
  ├─ Detects TZ → maps to country → maps to currency (from static JSON)
  ├─ Normalizes legacy codes (MAF→MAD, FRF→EUR, ...)
  ├─ Looks up session-cache FX rate (base→target)
  └─ If missing → calls /api/rates?base=USD&target=NGN

Server (/api/rates route)
  ├─ Try exchangerate.host/convert
  ├─ Try exchangerate.host/latest
  ├─ Try open.er-api.com/v6/latest
  ├─ Try jsDelivr fawazahmed0 files
  └─ Fallback { rate: 1 }
     ↳ CDN-cache headers (12h, stale-while-revalidate)

Detection without IP: timezone → country → currency
Keep a timezone → countryCode map (e.g., Africa/Lagos → NG).
Keep a countries.json with countryCode, currencyCode, currencySymbol.
Normalize legacy currency codes before using them.

Normalization table (partial)
const normalizeLegacyCode = (code) => { const map = { // Euro legacy to EUR FRF:'EUR', DEM:'EUR', ESP:'EUR', ITL:'EUR', NLG:'EUR', ATS:'EUR', PTE:'EUR', LUF:'EUR', FIM:'EUR', SIT:'EUR', // Morocco legacy MAF:'MAD', // Other renames you’re likely to hit CSK:'CZK', PLZ:'PLN', BUK:'MMK', ZRZ:'CDF', MXP:'MXN', RUR:'RUB', YUM:'RSD', YUD:'RSD', UYP:'UYU', VEB:'VES', GHC:'GHS', ZMK:'ZMW', RHD:'ZWL', KRO:'KRW', MDC:'MDL', MZE:'MZN', MKN:'MKD', }; return map[String(code || '').toUpperCase()] || String(code || '').toUpperCase(); };
Debugging tip: If your UI says “MAF” for Nigeria or Morocco, your static JSON is stale. Normalize it before using.

Client hook: useCurrency
Key responsibilities:

Read cookie override (currency_code) if present.
Derive default from timezone → country → currency.
Normalize legacy codes.
Fetch FX when needed (and cache).
Provide a formatter and a small symbol fallback for rare cases.

Client caching strategy

SessionStorage: cache (base → target) rate for ~6h.
Server: CDN cache (12h + stale-while-revalidate).

Server route: multi-provider FX fallback

I use a Next.js App Router route.js with a chain:
exchangerate.host (/convert then /latest)
open.er-api.com (/v6/latest/:BASE)
fawazahmed0 via jsDelivr (static daily files)
fallback (rate=1)

Each attempt is logged with provider name, status, and a tiny sample of the body (to avoid noisy logs).

Why a chain?

Resilience: providers fail, change terms, or rate-limit.
Accuracy: use a provider you trust; keep backups.
Observability: logs tell you which provider was used.

Caching, hydration, and flicker

Server sends cache headers: s-maxage=43200, stale-while-revalidate=86400, max-age=300
Client holds session FX for ~6h (fast re-renders).
Hydration: you can gate price rendering until detection is ready, or accept a minor flicker as price formats update. I prefer gating in critical price components and allowing light flicker in non-critical summaries.

UI: the “Switch currency” button

Bottom-right floating button.
Compact, keyboard-accessible, labeled “Switch currency”.
Selecting a currency writes a cookie and auto-refreshes—no “Apply” button.
This is key for correcting detection mistakes and for user agency.

Checkout integrity: snapshot the rate

Even if you convert on the fly, snapshot the applied FX rate at checkout:
Store { base, target, fxRate, provider, timestamp } with the order.
Use that snapshot for receipts, refunds, and audit trails.
Consider adding a “Last updated” label on the UI when showing converted totals.

Rounding and minor units

Intl.NumberFormat handles a lot, but you’ll still want rules:
Always round to 2 decimals for fiat? (Most, but not all.)
Respect currencies with 0 minor units (e.g., JPY).
For very large/small numbers, avoid scientific notation; clamp to fixed decimals.
A tiny fallback symbol map helps when Intl doesn’t recognize a code.

Observability & debugging

Log both sides:
Client: what you detected (tz, country, raw→normalized code), what you requested, and what rate you applied.
Server: which provider won, how long each attempt took, and a brief body sample.
This saved me when exchangerate.host suddenly returned missing_access_key and my NGN rate came from the fallback provider instead.

Security and maintenance notes

Don’t log entire payloads in production—sample and truncate.
If you add paid providers, keep keys in environment variables.
Periodically review your legacy normalization map and country JSON—these go stale.

Code: the pieces you’ll reuse
1) /app/api/rates/route.js (core idea)

import { NextResponse } from 'next/server';

const REVALIDATE_SECONDS = 60 * 60 * 12;

const EXHOST_CONVERT = 'https://api.exchangerate.host/convert';
const EXHOST_LATEST  = 'https://api.exchangerate.host/latest';
const ERAPI_LATEST   = 'https://open.er-api.com/v6/latest/';
const FAWAZ_BASE     = 'https://cdn.jsdelivr.net/gh/fawazahmed0/currency-api@1/latest/currencies';

const ISO4217 = new Set(['USD','EUR','GBP','CAD','AUD','NZD','JPY','CNY','INR','NGN','BRL','CHF','SEK','NOK','DKK','PLN','CZK','ZAR','KRW','TRY','AED','SAR','MXN','HKD','SGD','ILS','THB','MYR','PHP','IDR','PKR','RUB','HUF','RON','MAD','MMK','CDF','RSD','UYU','VES','GHS','ZMW','ZWL','MDL','MZN','MKD']);

const normalizeLegacyCode = (code) => {
  const map = { FRF:'EUR', DEM:'EUR', ESP:'EUR', ITL:'EUR', NLG:'EUR', ATS:'EUR', PTE:'EUR', LUF:'EUR', FIM:'EUR', SIT:'EUR',
                MAF:'MAD', CSK:'CZK', PLZ:'PLN', BUK:'MMK', ZRZ:'CDF', MXP:'MXN', RUR:'RUB', YUM:'RSD', YUD:'RSD',
                UYP:'UYU', VEB:'VES', GHC:'GHS', ZMK:'ZMW', RHD:'ZWL', KRO:'KRW', MDC:'MDL', MZE:'MZN', MKN:'MKD' };
  return map[String(code || '').toUpperCase()] || String(code || '').toUpperCase();
};

export async function GET(request) {
  const url = new URL(request.url);
  let base   = normalizeLegacyCode(url.searchParams.get('base') || 'USD');
  let target = normalizeLegacyCode(url.searchParams.get('target') || '');
  const amount = Number(url.searchParams.get('amount') || 1) || 1;
  const debug  = url.searchParams.get('debug') === '1';

  if (!ISO4217.has(base)) base = 'USD';

  if (target && base === target) {
    const payload = { base, target, amount, rate: 1, rates: { [target]: 1 }, providerUsed: 'short-circuit' };
    return withCaching(NextResponse.json(debug ? { ...payload, attempts: [] } : payload));
  }

  const attempts = [];
  const result =
      (target && await tryExHostConvert(base, target, amount, attempts))
   || await tryExHostLatest(base, target, attempts)
   || await tryOpenERAPI(base, target, attempts)
   || await tryFawazAhmed(base, target, attempts)
   || { base: 'USD', target, amount: 1, rate: 1, rates: { [target]: 1 }, providerUsed: 'fallback' };

  const body = debug ? { ...result, attempts } : result;
  return withCaching(NextResponse.json(body));
}

function withCaching(res) {
  res.headers.set('Cache-Control','public, s-maxage=43200, stale-while-revalidate=86400, max-age=300');
  return res;
}

async function tryExHostConvert(base, target, amount, attempts) {
  const qs = new URLSearchParams({ from: base, to: target, amount: String(amount) });
  const href = `${EXHOST_CONVERT}?${qs}`;
  const t0 = Date.now();
  try {
    const r = await fetch(href, { next: { revalidate: REVALIDATE_SECONDS } });
    const txt = await r.text();
    const json = safeJSON(txt);
    const rate = Number(json?.result);
    const ok = r.ok && Number.isFinite(rate) && rate > 0;
    attempts.push(rec('exchangerate.host/convert', href, r.status, ok, txt, t0));
    if (ok) return { base, target, amount, rate, rates: { [target]: rate }, providerUsed: 'exchangerate.host/convert' };
  } catch (e) {
    attempts.push(rec('exchangerate.host/convert', href, 0, false, String(e), t0));
  }
  return null;
}

async function tryExHostLatest(base, target, attempts) {
  const qs = new URLSearchParams({ base }); if (target) qs.set('symbols', target);
  const href = `${EXHOST_LATEST}?${qs}`;
  const t0 = Date.now();
  try {
    const r = await fetch(href, { next: { revalidate: REVALIDATE_SECONDS } });
    const txt = await r.text();
    const json = safeJSON(txt);
    const rate = Number(json?.rates?.[target]);
    const ok = r.ok && (!target || (Number.isFinite(rate) && rate > 0));
    attempts.push(rec('exchangerate.host/latest', href, r.status, ok, txt, t0));
    if (ok && target) return { base: json?.base || base, target, amount: 1, rate, rates: { [target]: rate }, providerUsed: 'exchangerate.host/latest' };
    return null;
  } catch (e) {
    attempts.push(rec('exchangerate.host/latest', href, 0, false, String(e), t0));
    return null;
  }
}

async function tryOpenERAPI(base, target, attempts) {
  const href = `${ERAPI_LATEST}${encodeURIComponent(base)}`;
  const t0 = Date.now();
  try {
    const r = await fetch(href, { next: { revalidate: REVALIDATE_SECONDS } });
    const txt = await r.text();
    const json = safeJSON(txt);
    const rates = json?.rates || {};
    const rate = Number(rates?.[target]);
    const ok = r.ok && json?.result === 'success' && (!target || (Number.isFinite(rate) && rate > 0));
    attempts.push(rec('open.er-api.com', href, r.status, ok, txt, t0));
    if (ok && target) return { base, target, amount: 1, rate, rates: { [target]: rate }, providerUsed: 'open.er-api.com' };
    return null;
  } catch (e) {
    attempts.push(rec('open.er-api.com', href, 0, false, String(e), t0));
    return null;
  }
}

async function tryFawazAhmed(base, target, attempts) {
  if (!target) return null;
  const href = `${FAWAZ_BASE}/${base.toLowerCase()}/${target.toLowerCase()}.json`;
  const t0 = Date.now();
  try {
    const r = await fetch(href, { next: { revalidate: REVALIDATE_SECONDS } });
    const txt = await r.text();
    const json = safeJSON(txt);
    const rate = Number(json?.[target.toLowerCase()]);
    const ok = r.ok && Number.isFinite(rate) && rate > 0;
    attempts.push(rec('fawazahmed0/currency-api', href, r.status, ok, txt, t0));
    if (ok) return { base, target, amount: 1, rate, rates: { [target]: rate }, providerUsed: 'fawazahmed0/currency-api' };
    return null;
  } catch (e) {
    attempts.push(rec('fawazahmed0/currency-api', href, 0, false, String(e), t0));
    return null;
  }
}

function safeJSON(t){ try { return JSON.parse(t); } catch { return null; } }
function rec(provider,url,status,ok,txt,t0){ const ms=Date.now()-t0; const sample=(txt||'').slice(0,300); console.log('[rates] attempt', JSON.stringify({provider,url,status,ok,ms,sample})); return {provider,url,status,ok,ms,sample}; }

2) Client hook (/hooks/useCurrency.js)—key ideas only
Read cookie override.
Detect via timezone map + countries JSON.
Normalize legacy codes.
Session-cache FX; call /api/rates otherwise.
Provide formatter, rate, currencyCode, and setUserCurrency.
(You already have a full version; this is the conceptual summary.)

3) “Switch currency” button
Bottom right, labeled “Switch currency”.
Select updates cookie and auto-reloads.
(You already shipped a styled version; keep it accessible and tiny.)

Environment variables
If you later plug in paid providers:

# .env
CURRENCYLAYER_KEY=…
FIXER_KEY=…
EXCHANGERATE_API_KEY=…  # if you move to their paid endpoint

Keep your /api/rates route aware of these and conditionally enable those branches.

Testing the hard parts
Normalization: Unit test normalizeLegacyCode with inputs from your static JSON.
Route: Integration test /api/rates?base=USD&target=NGN with mocked provider responses (success/timeout/invalid).
Formatting: Snapshot tests for different currencies (e.g., JPY 0 decimals, TND 3 decimals).
Browser: E2E test the “Switch currency” flow (cookie set + auto reload + updated price).

Known edge cases & mitigations
Provider outage → You get rate=1 fallback. Consider showing USD with a small “estimate” badge when fallback triggers repeatedly.
Extremely volatile FX (some markets) → shorten revalidate windows and snapshot at checkout.
Rounding disagreements (gateway vs. display) → ensure you and the gateway apply the same rounding rules on the same base amount.

What I learned (as a non-expert)
“Small UX niceties” require real engineering to be reliable.
Having both client & server logs made debugging straightforward.
A switcher isn’t awkward—it’s respectful. Let users correct you.
Auditable snapshots at checkout prevent all sorts of support headaches later.

Open questions for the community
Which FX provider do you trust most for production?
Do you show “Last updated (Source)” in the UI?
Have you had issues with specific currencies’ minor units?
Best practices you use to avoid SSR/hydration price flicker?

Wrap-up
If you only need USD, great. But if you want to welcome a global audience, a little work here dramatically improves trust and clarity. You don’t need a giant i18n project—just a practical pattern:
Detect politely, normalize aggressively, fetch resiliently, cache wisely, and give users a way to switch.
If you want the full code I used, I’m happy to share snippets or a template repo. And if you’ve solved this better, I’d love to learn from you. 🙏

Happy shipping.

Bootstrapping SaaS in 2025: Lessons from Building Postly and Onu

Paul Onu — Fri, 22 Aug 2025 16:20:17 +0000

Bootstrapping SaaS in 2025: Lessons from Building Postly and Onu

In the startup world, the stories that garner the most attention are typically those about massive funding rounds. Founders are raising millions before even launching. Unicorn valuations. Splashy headlines.

But what about those of us who don’t raise? What about the founders who bootstrap — who build with grit, creativity, and persistence instead of VC capital?

That’s been my story. I’m Paul Onu, founder of Postly Technologies, Inc., and over the last few years, I’ve been building two products — Postly and Onu — almost entirely bootstrapped. This is what I’ve learned about building SaaS in today’s world without the safety net of endless funding.

The Bootstrapping Reality

From the beginning, I knew I wasn’t cut out for a traditional 9–5. I’ve always been entrepreneurial at heart, and routine felt like a cage. With my background in Electronics Engineering and years of software engineering experience, I found myself drawn to product management — the sweet spot between vision and execution.

Bootstrapping wasn’t just a financial choice; it was a mindset. It forced me to prioritize ruthlessly, build lean, and listen closely to what customers wanted.

It’s not glamorous. It means saying “no” to ideas you love because there’s no budget. It means shipping slower than you’d like because resources are limited. But it also means every feature, every customer, and every dollar matters.

Building Postly in a Crowded Market

My first product, Postly, is an AI-powered social media publishing and collaboration platform. The social media management market is crowded, no doubt. However, it’s also enormous — projected to reach over $20 billion in the U.S. by 2030, driven by the $100 billion-plus global digital advertising industry.

How do you stand out in such a crowded space? By solving real pain points. Postly was built for creators, agencies, and marketing teams that wanted a smarter way to handle multi-platform publishing. Instead of clunky workflows, we focused on automation, AI-powered content creation, and team collaboration.

The most validating moment? We achieved early monetization within months. Customers were willing to pay. That’s when I knew we were solving a real problem.

Onu: The Future of Ambient AI

If Postly was about solving marketing headaches, Onu was born from something much more personal: overwhelm.

Like many entrepreneurs, I was juggling too much — managing my finances, tracking my productivity, trying to stay aware of my own energy and mood. None of the tools out there really “got it.” They were either too complex or too shallow.

That’s when the idea for Onu came to me: an ambient AI assistant for awareness, finance, and productivity. Instead of waiting for you to ask, Onu quietly tracks, analyzes, and offers insights in the background. It helps you notice patterns in your mood, spending, and even team meetings — things most of us overlook until it’s too late.

Early feedback has been exciting. Users call it a “wow” product, something that feels like it’s anticipating a future where AI isn’t just reactive, but proactively helpful.

Challenges and Lessons Along the Way

The hardest part of bootstrapping is obvious: resources. Every founder dreams of moving faster, but when funds are tight, you learn the art of patience and discipline.

For me, it’s been a crash course in:

Resilience: pushing forward even when progress feels slow.
Prioritization: deciding what’s truly essential.
Creativity: finding scrappy ways to do more with less.

There were moments when I almost gave up. But then a customer email would land, saying Postly saved them hours of work, or a user would tell me Onu helped them understand their own habits better. That’s the fuel that keeps you building.

The Road Ahead

Over the next three years, my ambitions are big:

Scale Postly into a top-tier SaaS platform in the U.S., serving tens of thousands of creators, agencies, and enterprises.
Establish Onu as the go-to app for ambient intelligence — creating a whole new category of productivity and finance tools.
Grow our team from about 15 today to 50+ talented builders, with a focus on creating jobs and innovation in the U.S.
Personally, I want to be recognized as a builder and thought leader in the space where SaaS and AI intersect.

It’s not about chasing hype. It’s about building products that make people’s lives simpler, smarter, and more meaningful.

Closing Thoughts

If there’s one thing I’ve learned, it’s this: you don’t need to be in Silicon Valley or have millions in the bank to make an impact. You need clarity, persistence, and a willingness to keep going when it feels impossible.

That’s the philosophy behind everything I’ve built so far. Postly proves that you can monetize early and win customers in a competitive market. Onu proves that innovation can be deeply personal and still resonate with others.

The journey hasn’t been easy, but it’s been worth it. And honestly? It’s only just beginning.

Why the Future of Productivity Lies in Ambient AI

Paul Onu — Fri, 22 Aug 2025 16:13:55 +0000

Why the Future of Productivity Lies in Ambient AI

For decades, productivity tools have been reactive. We ask them questions, they respond. We feed them data, they spit out graphs. But as AI evolves, a new paradigm is emerging: ambient intelligence — systems that operate quietly in the background, observing, analyzing, and offering insights before you even think to ask.

At its core, ambient AI is about shifting from “tools you use” to “tools that use context to help you.” It’s productivity without friction, decision-making without constant manual input. And if built correctly, it could redefine how we work, manage our finances, and even understand ourselves.

From Assistants to Awareness

Traditional assistants — whether Alexa, Siri, or even modern LLM-based chatbots — wait for commands. They’re useful, but fundamentally limited by the user’s initiative.

Ambient AI flips the script. Instead of waiting for prompts, it:

Listens (via speech and voice input).
Understands (through advanced sentiment and context analysis).
Remembers (via embeddings and retrieval).
Advises (by surfacing actionable insights in real time).

Imagine a system that flags recurring subscriptions you forgot, detects when a team meeting is veering off track, or nudges you about your rising stress levels — without you needing to search, query, or log anything. That’s where productivity is heading.

Building Ambient AI: The Onu Approach

At Onu, we’re building exactly this kind of ambient AI for individuals and teams. Our tech stack blends cutting-edge OpenAI models, real-time processing, and a lean backend to make proactive intelligence a reality.

1. Voice to Insight

ASR: We use whisper-1 for accurate transcription of voice recordings.
Analytics: Every transcript is analyzed by gpt-4.1, which extracts summaries, action items, key topics, emotions, and sentiment.
Storage: The raw data and structured JSON are stored in MongoDB for recall, visualization, and further training.
Outcome: A meeting isn’t just recorded — it’s instantly summarized, annotated, and ready for action.

2. Finance to Decision

Data Ingest: Transactions flow in via Plaid or other APIs.
Categorization: gpt-4.1 classifies merchants, expenses, and bills.
Forecasting: Rolling sums and LLM-based summaries predict cash flow and detect anomalies.
Outcome: A user doesn’t just see their balance — they’re warned about an upcoming shortfall or alerted when a recurring bill spikes.

3. Search + RAG

Embedding: All transcripts and notes are embedded with text-embedding-3-large.
Retrieval: Queries like “What needs my attention this week?” fetch semantically relevant items across voice + finance data.
Reasoning: Responses are generated by gpt-4.1, with escalation to gpt-5 for complex, long-form reasoning (Team plan only).
Outcome: Search becomes contextual, not keyword-based.

4. Voice Commands

Trigger: Users invoke “Hey Onu” to route voice intents.
Parsing: gpt-4.1 parses the request: recording, dashboard query, finance question.
Execution: The backend executes the intent via Dart-based APIs and MongoDB storage.
Outcome: A hands-free productivity experience, like having a proactive teammate always listening.

The Business Layer

Ambient AI isn’t just a technical experiment; it has a massive market opportunity.

Productivity SaaS TAM: Over $100B globally, with the U.S. as the primary growth market.
Finance Intelligence TAM: Consumer finance software is forecast to surpass $1.7B by 2030, but ambient AI could expand that drastically by embedding finance into everyday awareness.
Differentiation: While giants focus on assistants (ChatGPT, Gemini, Alexa), there’s a gap in awareness-first AI that feels personal, not transactional.

For Onu, monetization ties to quotas (recording minutes, API calls, embeddings, etc.), integrated via Stripe. This ensures cost control, predictable unit economics, and tiered pricing for individuals and teams.

Engineering for Scale (Lean but Robust)

Our backend stack reflects the startup reality: lean, modular, and cost-conscious.

Runtime: Dart (Shelf/Dart Frog) for APIs, WebSockets for live capture.
Storage: MongoDB for transcripts, embeddings, and insights.
Workers: Dart isolates manage ASR, embeddings, and LLM calls.
Queues: Redis/Mongo-backed jobs for retries and async pipelines.
Observability: Logs track token usage, latency, and per-user costs.
Cost Control: Batch embeddings, cache merchant categorizations, and escalate from gpt-4o-mini → gpt-4.1 only on low confidence.

These aren’t just engineering details; they’re business necessities. Ambient AI must balance accuracy with cost, otherwise it can’t scale sustainably.

Why Ambient AI is the Future

Every major shift in productivity has been about removing friction:

Word processors removed typewriters.
Email replaced paper memos.
Cloud collaboration eliminated file chaos.
LLMs replaced keyword search with natural conversation.

The next leap? Products that remove the need for you to even ask.

That’s what ambient AI promises: tools that proactively surface the right context at the right time, turning raw data into awareness and awareness into action.

And that’s why I believe — as both a founder and a technologist — the future of productivity lies in ambient AI.