DEV Community: Tanishpaul

Stop Using Spreadsheets for Your Trading Journal — Here's Why

Tanishpaul — Tue, 21 Jul 2026 03:31:54 +0000

Stop Using Spreadsheets for Your Trading Journal — Here's Why

If you're tracking your trades in a spreadsheet, you're working harder than you need to and getting less insight than you deserve.

I see it everywhere — Reddit threads, Discord servers, trading communities. Someone shares a Google Sheets template with 47 columns, color-coded P&L cells, and a pivot table that breaks every time they add a row. They call it their "trading journal." It's not. It's a liability.

I've been building TradesLog — a free trading journal app — for the last few months, and the more I talk to traders about their workflows, the more I realize how much the spreadsheet is holding them back. Not because spreadsheets are bad tools, but because they're the wrong tool for this job.

Let me break down why.

The Spreadsheet Trap

Here's what usually happens. You start trading. You want to track your performance. You open Google Sheets because it's free and you already know how to use it. You add columns: date, ticker, entry, exit, P&L, notes. So far so good.

Then you want to see your win rate. So you add a formula. Then you want to see your average R-multiple. Another formula. Then you want to filter by strategy, by day of week, by market condition. Now you're writing QUERY() functions or building pivot tables that reference ranges that shift every time you insert a row.

Two months in, your spreadsheet is a fragile house of cards. One wrong cell edit and your stats are wrong. And you probably won't notice — because you're trusting the numbers to make trading decisions.

A trading journal isn't just a record. It's the tool you use to find your edge. If that tool is fragile, your edge is fragile.

What a Trading Journal App Does That a Spreadsheet Can't

1. Structured Data That Doesn't Break

In a spreadsheet, every row is a free-for-all. You can type text in a number column. You can delete a formula. You can accidentally sort one column without the others. There's no integrity.

A dedicated trading journal app enforces structure. Every trade has the right fields. Entry price is a number. Strategy is a dropdown. Date is a date. You can't break the schema because the app won't let you.

This sounds boring until you've spent an hour debugging a broken VLOOKUP at 11 PM.

2. Instant Analytics Without Formulas

Your win rate. Your average gain vs. average loss. Your P&L by strategy, by ticker, by day of week, by session. These should be one click, not a formula you have to remember or copy from a tutorial.

In TradesLog, you log a trade and your stats update instantly. No formulas. No pivot tables. No "did I break something when I added that last row?" anxiety.

3. Pattern Recognition You Can Actually See

The whole point of journaling is spotting patterns. I win more on breakout setups in the first hour. I lose money on Wednesdays. My size is too big on red days.

A spreadsheet can show you the raw data, but connecting those dots requires you to already know what to look for. A journal app can surface those patterns visually — charts, heatmaps, breakdowns — so you notice things you wouldn't have thought to query.

4. Mobile Logging (Because You Trade on the Go)

Most traders aren't at a desk with a 27-inch monitor all day. You're on your phone between meetings. You closed a position on the subway. You had a thought about a setup while walking the dog.

With a spreadsheet, you either wait until you're at a computer (and forget half the details) or you wrestle with the mobile Sheets app (and fat-finger a formula). A journal app is built for mobile. Open it, log the trade in 30 seconds, move on.

5. Notes That Are Actually Searchable

Your trading notes are where the gold is. "FOMO entry, chased the move." "Perfect setup, sized too small." "Should have waited for the retest." These micro-observations, accumulated over hundreds of trades, are what make you better.

In a spreadsheet, notes are a single text cell in a sea of rows. Good luck searching through 500 trades to find every one where you wrote "FOMO."

In a journal app, notes are searchable, taggable, and connected to the trade data. You can filter every trade where you noted "FOMO" and instantly see what it cost you. That's insight, not just record-keeping.

"But Spreadsheets Are Free"

So is TradesLog.

The "free" argument for spreadsheets made sense when the alternative was a $40/month subscription to some bloated trading platform. But a free, purpose-built journal app gives you the structure and analytics without the cost — and without the spreadsheet tax of maintaining your own formulas, fixing broken pivots, and wondering if your stats are actually correct.

Your time has value. Every hour you spend building spreadsheet formulas is an hour you're not spending reviewing trades, refining your strategy, or just living your life.

The Real Cost of Bad Journaling

Here's the uncomfortable truth: most traders don't journal at all. And the ones who do often use a tool that's so painful to maintain that they stop after a few weeks.

The traders who consistently improve are the ones who have a system they actually stick to. If your journal is a spreadsheet you dread opening, you'll stop using it. If it's an app that takes 30 seconds per trade and shows you something useful every time you open it, you'll keep coming back.

That consistency gap is the difference between a trader who improves over six months and one who's still making the same mistakes in year three.

What I'm Building With TradesLog

TradesLog is a clean, free trading journal app built for traders who want to actually use their data instead of just storing it. Here's what it does:

Fast trade logging — entry, exit, P&L, strategy, notes in seconds
Automatic analytics — win rate, average R, P&L breakdowns by every dimension
Pattern visibility — see where you win and where you bleed, without writing a single formula
Searchable notes — tag and find your trading mistakes and strengths instantly
Free forever — no subscription, no paywall, no "premium tier" that hides the features you actually need

I'm building it in public as a solo founder, and I'm talking to traders every week about what they need. If you're using a spreadsheet right now, I'd love for you to try it and tell me what's missing.

Stop Spreadsheets. Start Journaling Properly.

If you're serious about trading, your journal is the highest-leverage tool you own. Not your charting software. Not your broker. Your journal is where you turn experience into edge.

A spreadsheet gives you a record. A journal app gives you insight. The difference matters more than you think.

Try TradesLog free → tradeslog.base44.app

No signup wall. No subscription. Just a better way to track your trades and find your edge.

Building in public. Follow along for more devlogs, trading journal tips, and indie SaaS stories.

How I Built an AI Data Extraction Tool as a Solo Founder in India

Tanishpaul — Mon, 20 Jul 2026 03:31:32 +0000

How I Built an AI Data Extraction Tool as a Solo Founder in India

Building a SaaS product alone is hard. Building one that uses AI to extract structured data from messy documents — from India, with no team, no funding, and no safety net — is a different kind of challenge entirely.

I'm Tanish, a solo founder based in India. I built DataSwift AI, a tool that takes any document — invoices, receipts, forms, bills — and uses AI to extract and structure the data automatically. No manual data entry. No copy-pasting. Just upload and export.

Here's exactly how I did it, what I learned, and why I think India is the best place in the world to build indie SaaS right now.

The Problem I Was Trying to Solve

Every small business I talked to had the same bottleneck: manual data entry. Accountants typing invoice numbers into spreadsheets. Ops managers copy-pasting line items from PDFs into their CRM. Shop owners spending hours reconciling receipts.

It's slow. It's error-prone. And it scales terribly.

The existing solutions were either:

Enterprise OCR tools that cost $200+/month and need a team to configure
Generic AI chatbots that don't export structured data
Zapier-style automations that break the moment a document format changes

None of these work for a small business with 50 invoices a month and no tech team.

The Stack: What I Used to Build It

I kept it deliberately simple. As a solo founder, you don't have the bandwidth to maintain a complex infrastructure.

Frontend: React + Tailwind (fast to ship, easy to iterate)
Backend: Base44 (managed backend with entities, auth, and API functions — no server management)
AI: GPT-4o for document understanding and structured data extraction
Hosting: Netlify for the frontend, Base44 for the backend
Payments: Crypto-friendly per-document pricing (no subscription)

The key decision was using AI models that can understand document structure semantically — not just OCR the text, but actually understand what's an invoice number, what's a line item total, and what's a vendor name.

Why I Chose Pay-Per-Document Over a Subscription

Every SaaS guru will tell you to charge a monthly subscription. I disagree.

Small businesses don't process documents every day. Some process 10 a week. Some process 200 in one sitting at month-end. Forcing them into a $49/month subscription means they're paying for capacity they don't use most of the time.

So I made DataSwift AI pay per document. You buy credits. You use them when you need them. They don't expire.

This model works because:

Lower barrier to entry — no commitment, just try it
Fair pricing — you pay for value received, not for access
Crypto-friendly — many Indian small businesses prefer UPI and crypto over credit card subscriptions

Building From India: The Advantages Nobody Talks About

People assume building SaaS from India is a disadvantage — limited funding, smaller local market, payment infrastructure issues. In reality, it's the opposite:

Low burn rate: My monthly costs are under ₹5,000 (~$60). Try running a startup in San Francisco on that.
Time zone advantage: While the US sleeps, I ship. By the time they wake up, features are deployed and tested.
India's digital infrastructure: UPI, Aadhaar, and the India Stack make it trivially easy to build payment and identity flows.
The market is massive: India has 63+ million SMEs. Even 0.01% adoption is 6,300 paying customers.

The biggest challenge isn't infrastructure — it's distribution. Getting your product in front of the right people. That's why I'm building in public, writing articles like this one, and talking to every small business owner I can find.

What I'd Tell My Past Self Before Starting

1. Start with the hardest problem first.

I almost built a generic document scanner first, then layered AI on top. Wrong move. Start with the AI extraction — that's the hard part. Everything else (UI, payments, export) is straightforward.

2. Don't build features nobody asked for.

I spent 3 weeks building a custom dashboard with charts and analytics. Users wanted one thing: upload document → get data → export. I deleted the dashboard.

3. Charge from day one.

Free users give you bad feedback. They don't care because they haven't paid. The moment someone pays even ₹10, their feedback becomes sharp, specific, and actionable.

What's Next for DataSwift AI

The roadmap is simple:

More document types: Currently handles invoices and receipts. Adding bank statements, purchase orders, and customs forms.
Direct CRM exports: Push structured data straight into Zoho, Tally, and Google Sheets.
API access: Let developers integrate DataSwift AI into their own workflows.

I'm not raising funding. I'm not hiring a team. I'm building this solo, shipping fast, and letting the product speak for itself.

Try It Yourself

If you or your business deals with document-heavy workflows — invoices, receipts, forms — give DataSwift AI a try. No subscription. Pay per document. Crypto-friendly.

🔗 Start extracting data with AI →

I'm actively looking for feedback from accountants, ops managers, and small business owners. Reach out and tell me what's broken about your current workflow — I'll fix it.

Built in public from India 🇮🇳. Follow along as I scale this to 10,000+ users.

What If Your Phone Addiction Was Actually Building an Empire? (A Game Dev Story)

Tanishpaul — Sun, 19 Jul 2026 03:33:15 +0000

What If Your Phone Addiction Was Actually Building an Empire? (A Game Dev Story)

We all know the feeling. You pick up your phone for "just a minute" and suddenly it's 2 AM, you've watched 40 short videos, and your thumb hurts. Doomscrolling is the defining habit of our generation — and nobody really talks about how weird it is that we do it willingly.

So I did what any indie game developer does when they notice something uncomfortable about modern life: I made a game about it.

It's called Doomscroll 2077: The Idle Empire, and it turns the exact loop of compulsive phone-checking into a cyberpunk empire-builder. You tap to scroll, you earn DATA, you spend it on upgrades, and eventually you prestige into a bigger, shinier version of the same cycle. Sound familiar?

Here's the story of why I built it, what I was trying to say with it, and what happened when I let people play it for free in their browser.

The Idea: Make the Habit Visible

The core insight was simple. Doomscrolling feels meaningless because there's no feedback. You scroll, time disappears, and you get nothing back. What if the scrolling did something? What if every swipe fed a machine that was growing, leveling up, and producing bigger numbers?

That's the idle game loop in a nutshell: tap → earn → upgrade → tap faster → prestige → repeat. It's already how TikTok and Instagram work under the hood — they just don't show you the scoreboard.

I wanted to expose that scoreboard. Make the addiction loop honest. When you play Doomscroll 2077, you're not pretending you're saving a kingdom or fighting a war. You're literally just scrolling. The game doesn't hide it. And that honesty is what makes it uncomfortable — and, honestly, kind of funny.

Building the Cyberpunk Vibe

I chose a cyberpunk aesthetic because it fits the theme perfectly. Neon everything. Megacorporations. A currency called AURA that you grind for. A world where data is the most valuable resource and your attention is the product.

The art direction was intentionally lo-fi but saturated — glowing CRT screens, scanlines, glitch effects. I wanted it to feel like you were inside the machine, not watching it from outside.

The UI borrows from the apps that designed the doomscroll in the first place: infinite scroll, dopamine-streak counters, "you've been scrolling for X minutes" timers that are part of the game rather than warnings against it.

The Core Loop (And Why It Works)

Here's how a session of Doomscroll 2077 actually plays:

You scroll. Each scroll generates DATA — the base currency.
You spend DATA on upgrades. Bigger scroll yield, auto-scrollers, data miners.
Auto-scrollers take over. Soon the game scrolls itself — the idle part.
You hit a wall. Progress slows. This is where most idle games lose players.
You prestige. Reset everything, but keep a permanent multiplier (AURA). The next cycle is faster and shinier.
Repeat. Bigger numbers, new upgrades, new prestige layers.

The genius (and the critique) is that this is exactly how social media engagement loops work. The game is a mirror. The fact that players find it addictive is the point.

The Prestige System: AURA and the Long Game

Most idle games have a prestige mechanic, but I wanted ours to feel thematic, not just numerical. So instead of "reset for +10% production," you reset to bank AURA — a currency that represents your accumulated attention capital.

AURA persists across runs and unlocks new tiers of upgrades, new visual themes, and new "corporations" you can found. Each prestige is framed as founding a new megacorp in the city. You're not just grinding numbers; you're literally building an empire of attention.

This gives long-term players a reason to keep coming back beyond raw numbers. There's a narrative arc: scrub startup → mid-tier corp → neon megacorp dominating the skyline.

Why I Made It Free (And Why That Was the Point)

I made Doomscroll 2077 free, no signup, no download — just open the link and play. Three reasons:

Friction kills the experiment. If someone has to install something to experience a game about instant-gratification loops, the joke doesn't land.
Free indie games are incredible marketing. A free browser game with a strong hook spreads faster than any paid release. Players share it. Streamers play it. It indexes.
Accessibility. I wanted anyone — a curious teenager, a burned-out founder, someone on a 15-minute break — to be able to try it instantly.

Free-to-play browser games are undersold as a strategy. If your game is good and the hook is fast, "free" isn't a sacrifice. It's the distribution channel.

What Happened When People Played It

The reaction was more interesting than I expected. A lot of players said the same thing: "I didn't realize how much this resembles what I actually do on my phone."

Some people played for five minutes and left. Others sank hours. A few told me they uninstalled a social app after playing — which is either the highest compliment a game can get or a sign I made something too effective.

The lesson I took from it: games that tell the truth about how we already behave hit differently. You don't need a big budget. You need a sharp idea and the honesty to execute it.

What I'd Tell Other Indie Devs

If you're an indie developer wondering whether to build something small, weird, and free — do it. The barrier is lower than ever. Browser games, idle mechanics, and a strong thematic hook can get you further than months of polish on something generic.

Pick an idea that makes you slightly uncomfortable. Build the smallest version of it. Ship it free. Let people feel it.

That's how Doomscroll 2077 started — one developer, one uncomfortable observation, and a browser tab.

Play It Free

Doomscroll 2077: The Idle Empire is free to play, right in your browser. No download, no signup, no paywall — just open and start building your empire of attention.

👉 Play Doomscroll 2077 now →

Building in public. Follow along for more devlogs, game design breakdowns, and indie dev stories.

How I Built a Browser Game That Hooks Players in Under 15 Seconds

Tanishpaul — Sat, 18 Jul 2026 03:32:18 +0000

Most browser games lose players before the first minute. The loading screen kills momentum. The tutorial drags. The player tabs out and never comes back.

I learned this the hard way building Neon Starfighter: Overdrive — a free browser space shooter. After watching early playtest sessions, I realized the first 15 seconds determine everything. If a player isn't shooting, dodging, and feeling something by second 15, they're gone.

So I rebuilt the opening experience around a single principle: get the player into action immediately. No download. No signup. No tutorial modal. Click the link, and you're flying a ship.

Here's what I learned about browser game design and how I engineered that critical first-15-second hook.

The 15-Second Rule for Browser Games

When someone clicks a link to a browser game, they're operating on curiosity, not commitment. They're giving you a tiny window of attention. Here's what kills that window:

Loading screens — anything over 3 seconds and bounce rates spike
Account walls — "sign up to play" is a death sentence for a free browser game
Tutorial overlays — text boxes explaining controls before the player has felt the game
Empty space — starting the player in a calm, empty area instead of mid-action

For Neon Starfighter, I designed the opening seconds like this:

Instant load — the game is a lightweight HTML5 canvas app. No Unity WebGL blob, no heavy framework. It loads in under 2 seconds on average mobile data.
Mid-action start — the player's ship appears on screen with enemies already approaching. The first enemy enters the firing arc within 2 seconds.
Auto-fire default — the ship shoots automatically. The player only needs to move. This removes the "what button do I press?" friction.
Immediate visual feedback — explosions, screen shake, combo counter. Every hit feels good in the first 5 seconds.

Designing the Hook: What Makes a Space Shooter "Click"

The core loop of Neon Starfighter is simple: move, shoot, dodge, build combos. But the feel is what hooks players. Here are the browser game design tips I applied:

1. Juice Over Complexity

I spent more time on particle effects, screen shake, and hit-stop frames than on the actual enemy AI. When you destroy an enemy, the screen punches outward slightly, debris scatters, and the combo counter ticks up with a satisfying animation. These micro-feedback moments are what make an indie browser game feel polished — not the number of levels or features.

2. The Combo System as a Retention Hook

Combos are the heartbeat of the game. Chain kills without taking damage and your multiplier climbs. Break the chain and it resets. This creates a risk-reward tension that's instantly understandable:

Safe play = low score, low combo
Aggressive play = high score, high risk

Players don't need a tutorial to understand this. They feel it within the first 10 seconds — kill two enemies quickly, see the combo counter spin, and they're locked in.

3. One-Handed Mobile Controls

A huge chunk of browser game traffic is mobile. If your game requires two thumbs and a keyboard, you've already lost half your players. Neon Starfighter uses a single-touch control scheme: touch and drag to move, auto-fire handles the rest. It works on phones, tablets, and desktops with zero configuration.

The Technical Stack: HTML5 Canvas, Not a Game Engine

This is one of the biggest indie game dev lessons I learned: you don't always need a game engine.

Neon Starfighter is built on raw HTML5 Canvas with vanilla JavaScript. Here's why:

Load time — a canvas game with optimized sprites loads in under 2 seconds. A Unity WebGL export can be 10-20MB before the player sees anything.
Mobile compatibility — canvas runs everywhere a browser runs. No plugin issues, no WebGL compatibility headaches on older devices.
Iteration speed — changing a game mechanic is editing a JS file and refreshing. No build pipeline, no compile step.

The trade-off is that you build everything yourself — collision detection, particle systems, input handling. But for a space shooter, the scope is manageable, and the performance payoff is worth it.

Architecture Quick Overview

/game
  /src
    main.js        → game loop, state management
    player.js      → ship movement, auto-fire
    enemies.js     → spawn system, enemy AI
    particles.js   → explosions, debris, trails
    combos.js      → combo tracking, multiplier
    audio.js       → Web Audio synth (no sound files)
  index.html       → canvas element, one script tag

The entire game is under 500KB including sprites. That's smaller than a single high-res PNG.

SEO and Discovery: Why Free Browser Games Win on Google

Here's something most indie devs miss: free browser games are incredibly SEO-friendly.

When someone searches "free space shooter game" or "play browser game no download," they want instant gratification. A game that loads in 2 seconds and requires no signup satisfies that intent perfectly. Google rewards this with low bounce rates, long session durations, and return visits.

I targeted specific keywords in my game's meta description and landing page:

"free browser space shooter game"
"play space game no download"
"indie browser game 2026"

The result: organic search traffic that compounds over time. Each article, each pin, each shared link adds another entry point in Google's index.

What I'd Do Differently

Building Neon Starfighter taught me a few things I'll carry into my next project:

Start with the hook, not the story. I initially spent a week writing lore and backstory. Nobody cared. Players wanted to shoot things immediately.
Test on a slow phone first. My development machine ran the game at 120fps. A budget Android phone ran it at 18fps until I optimized. Always test on the worst device you can find.
Sound matters more than you think. I almost shipped without audio. Adding a simple Web Audio synth for explosions and combo ticks increased average session length by 40%.

The Marketing Lesson: Games as Growth Tools

I'm a SaaS founder. Building a free browser game wasn't a side project — it was a strategy.

Free indie games are the best marketing that doesn't feel like marketing. A player who enjoys Neon Starfighter remembers BlueAuric Studio. When they later see DataSwift AI or TradesLog, there's brand recognition. The game is a funnel that doesn't look like a funnel.

And on Google, a free playable game outranks a landing page every time. "Play a free space shooter" is a better search result than "try our data extraction tool." The game earns clicks the landing page never could.

Play It Yourself

Neon Starfighter: Overdrive is free, runs in any browser, and requires no download or signup. Just click and play.

Play Neon Starfighter: Overdrive — Free Browser Space Shooter →

If you're a game dev, a SaaS founder thinking about building a game for growth, or just someone who wants to blow up some neon spaceships on a Saturday — give it a try. It takes 15 seconds to load and hopefully a lot longer to put down.

Building indie games and SaaS tools in public from India. Follow along as I ship more projects at BlueAuric Studio.

The One Tool Every Serious Trader Needs But Nobody Talks About

Tanishpaul — Fri, 17 Jul 2026 03:32:07 +0000

Every trader knows the feeling. You start the day confident — charts checked, news scanned, levels set. Then somehow you end the day down again, wondering what went wrong.

Most traders blame the market or the setup. But the real problem is almost never the strategy. It's the lack of a system for tracking and reviewing trades.

If you're not journaling every trade, you're gambling with your edge.

Why a Trading Journal Is the Missing Link

Every professional trader keeps a journal. Hedge funds track every position. Prop desks log every entry with notes on why the trade was taken. Meanwhile, retail traders rely on memory and gut feeling.

That gap is why 90% of retail traders lose money.

A trading journal does three things your brain can't:

Removes emotion from review. Logging a trade before knowing the outcome captures real reasoning, not post-hoc rationalization.
Reveals hidden patterns. Maybe you lose 3x more on Mondays. Maybe your win rate drops after 2pm. Maybe you size up after losses. You won't catch that without data.
Builds accountability. Knowing you have to write "entered FOMO, no setup, sized too large" makes you think twice before clicking buy.

What Most Traders Get Wrong

"I use a spreadsheet."
A spreadsheet is barely better than nothing. Columns of numbers with no real insight. No tagging by strategy. No win-rate by setup. And after a long session, nobody wants to manually format Excel cells.

"I'll remember what happened."
After 20 trades a week, the specifics blur. You'll remember big winners and painful losers — and forget the mediocre trades that quietly drained your account.

"I don't have time."
Traders spend hours scanning charts and scrolling Twitter for alpha — but won't spend 60 seconds logging a trade that could reveal a leak costing thousands.

What a Real Trading Journal Should Do

This is why I built TradesLog — a free trading journal app that does what spreadsheets can't:

Log trades in seconds — entry, exit, strategy tag, notes, screenshots. Under a minute per trade.
Track your edge by setup — win rate, average R-multiple, profit factor broken down by strategy.
Spot patterns automatically — worst-performing day, average hold time, overtrading alerts.
Zero cost to start — no subscription, no credit card. Sign up and journal.

The Data Tells the Story

A trader I know was convinced his breakout strategy was his best performer. After 3 months of journaling, the data showed: breakout win rate was 38%, mean-reversion was 61%. He was emotionally attached to exciting trades, not profitable ones.

That's the power of a journal — it shows you the truth even when it's uncomfortable.

Your Edge Is Already There

The difference between blowing your account and becoming profitable often isn't talent. It's self-awareness. And the fastest path to self-awareness in trading is a detailed, honest record of every decision.

If you're not journaling right now, you're leaving money on the table.

Start tracking your edge today.

Try TradesLog — It's Free

Start journaling your trades now →

TradesLog is a free trading journal app built for traders who want to stop guessing and start improving. Log trades, track your edge, and turn your data into better decisions.

Pay Per Document, Not Per Month — The SaaS Pricing Model That Actually Makes Sense

Tanishpaul — Thu, 16 Jul 2026 03:32:11 +0000

Pay Per Document, Not Per Month — The SaaS Pricing Model That Actually Makes Sense

If you run a small business, you've probably felt this: another $49/month SaaS subscription sitting in your billing dashboard, quietly draining your budget — and you used it maybe three times last month.

The subscription model is broken for a specific kind of tool. Not your CRM. Not your email. But the tools you use occasionally — the ones that sit idle 25 days a month and then get hammered for two days during a quarterly crunch.

Document data extraction is the perfect example. You don't process invoices every single day. But when you do — 50 invoices on the last Friday of the month — you need it to work fast and flawlessly.

So I built DataSwift AI with a different pricing model: pay per document, not per month.

Here's why this matters, how it works, and why I think more SaaS tools should follow this approach.

The Problem With Subscription Pricing for Occasional Tools

Most data entry and document processing tools lock you into a monthly plan. The pricing looks like this:

Starter: $29/month → 100 documents
Pro: $79/month → 500 documents
Enterprise: Custom

If you process 20 documents a month, you're paying for 80 you'll never use. If you spike to 200 during tax season, you're throttled or forced to upgrade mid-task.

This model optimizes for the vendor's recurring revenue, not the customer's actual usage pattern.

Pay Per Document: How It Works

DataSwift AI flips the model. Here's the flow:

Upload any document — invoices, receipts, purchase orders, forms, ID cards
AI extracts the structured data — vendor name, dates, line items, totals, tax fields
Review and export — send it to your database, CRM, or download as CSV/JSON

You pay only for the documents you actually process. One document costs a few cents. No monthly fee. No tier you have to babysit. No "upgrade to continue" pop-up in the middle of your workflow.

If you process 5 documents this month, you pay for 5. If you process 500 next month, you pay for 500. The math is honest.

Why This Model Works Better for Small Businesses

I've been building DataSwift AI in public as a solo founder from India, and the feedback from small business owners has been consistent: they don't want another subscription.

Here's why pay-per-use wins for this category:

You're Not Penalized for Growing Slowly

With subscriptions, a new business paying $49/month for a tool they barely use is bleeding cash during their most vulnerable phase. Pay-per-use means your costs scale with your actual volume — not an arbitrary tier.

No Vendor Lock-In

Cancel a $49/month subscription and you lose access to everything. With pay-per-document, there's nothing to cancel. You just stop using it. Your account stays, your history stays, and you come back when you need it.

Transparent Pricing

You know exactly what each document costs. There's no "credits" system, no "tokens" that expire, no "seats" to manage. One document. One price. Done.

The Technical Side: What Makes It Work

DataSwift AI uses a fine-tuned extraction pipeline that handles:

Invoice OCR — line items, tax breakdowns, vendor details
Receipt digitization — date, total, merchant, category
Form field extraction — structured data from semi-structured documents
Multi-format support — PDF, images, scans, even photos taken on a phone

The AI handles messy, real-world documents — not just clean digital PDFs. Crumpled receipts, tilted scans, handwritten notes mixed with printed text. That's where traditional OCR fails and where AI extraction earns its keep.

Who This Is For

Accountants and bookkeepers processing batches of client invoices
Ops managers digitizing paper-based workflows
E-commerce sellers reconciling supplier receipts
Solo founders and freelancers who can't justify another monthly SaaS bill
Anyone who's tired of paying for software they barely use

The Bigger Trend: Usage-Based SaaS Is Coming

I'm not the only one thinking this way. Companies like Stripe, AWS, and Twilio built empires on usage-based pricing. The model is proven at scale. What's changing is that smaller, niche tools are now adopting it too — because customers are demanding it.

The SaaS subscription fatigue is real. People are auditing their billing dashboards, cutting tools, and asking: do I actually use this enough to justify the monthly cost?

Pay-per-document isn't a gimmick. It's a return to a simpler principle: pay for what you use, nothing more.

Try It Yourself

If you deal with document data entry — invoices, receipts, forms — and you're tired of monthly subscriptions for a tool you use a few times a week, give DataSwift AI a try.

No signup wall. No credit card required to start. Upload a document, see the extraction, and decide if it's worth it.

Try DataSwift AI — Pay Per Document, No Subscription →

Built solo, in public, from India. Feedback welcome.

If you found this useful, share it with someone who's drowning in manual data entry. Follow along as I build DataSwift AI and other tools in public.

The Idle Game Loop That Keeps Players Coming Back — A Doomscroll 2077 Devlog

Tanishpaul — Wed, 15 Jul 2026 03:32:09 +0000

When I started building Doomscroll 2077: The Idle Empire, I had one question nagging at me: why do idle games keep people playing for hours when nothing is really happening?

The answer is the loop. Not just any loop — a loop that rewards, surprises, and scales. In this devlog, I'm breaking down exactly how I designed the idle game loop in Doomscroll 2077, what mechanics drive retention, and what I learned about incremental game design along the way.

The Core Loop: Scroll → Earn → Upgrade → Scroll Faster

Every idle game lives or dies by its core loop. Here's how it works in Doomscroll 2077:

You scroll (the cyberpunk "doomscroll" action — your finger never stops)
Each scroll earns AURA — the in-game currency that powers your empire
You spend AURA on upgrades — auto-scrollers, data miners, influence bots
Upgrades increase your scroll speed and AURA per scroll
Faster scrolling = more AURA = bigger upgrades

It's a compounding feedback loop. The first 30 seconds feel slow. By minute two, numbers are flying. By minute five, you're managing an automated scrolling empire.

Why This Loop Works

The genius of idle game design isn't complexity — it's timing. Here are the three principles I followed:

1. Short Reward Cycles

Every tap gives immediate feedback. AURA ticks up, numbers flash, the UI reacts. The brain gets a dopamine hit every 2-3 seconds. This is the "doomscroll" metaphor made literal — the game rewards the exact behavior that makes real scrolling addictive, but turns it into something fun.

2. Unlock Pacing

New upgrades unlock at exponential cost curves. This creates natural "just one more upgrade" moments. You're always 20% away from the next thing. That gap is the hook.

3. Prestige Reset

Once your empire is fully automated, you hit a wall. That's where the prestige system kicks in — you reset everything but keep a permanent multiplier. This solves the #1 problem with idle games: they get boring once you max out. The prestige reset gives players a reason to start over, stronger.

The Cyberpunk Flavor

The loop mechanics would work in any theme. But setting it in a neon-drenched 2077 cyberpunk world — where you're literally building a media empire by doomscrolling — gives every upgrade narrative weight.

Your auto-scrollers aren't just "bots." They're data miners scraping the neon internet. Your influence upgrades aren't just "multipliers." They're propaganda algorithms shaping public opinion. The theme and the mechanics reinforce each other.

What I'd Do Differently

If I were rebuilding the loop today, I'd add more mid-game variety. The first 5 minutes are electric. Minutes 10-15 can sag before prestige unlocks. I'd introduce a "breaking news" event system — random bonuses that spike engagement during the mid-game lull.

Play It Free

No download. No signup. No paywall. Just open the link and start scrolling.

Play Doomscroll 2077: The Idle Empire →

It's a free cyberpunk idle game that runs right in your browser. If you've ever fallen down a doomscroll rabbit hole at 2 AM, this game is for you — except this time, the scrolling actually builds something.

Keywords: idle game design loop, incremental game mechanics, cyberpunk idle browser game, indie game devlog

I Built a Free Browser Space Shooter — Here's What I Learned About Game Dev

Tanishpaul — Sat, 11 Jul 2026 03:31:13 +0000

I Built a Free Browser Space Shooter — Here's What I Learned About Game Dev

When I decided to build a browser-based space shooter game as a side project, I had no idea it would teach me more about game design, player psychology, and indie development than a year of studying.

The Premise

Neon Starfighter: Overdrive is a free, no-download browser space shooter. You fly a neon ship through an endless stream of enemies, dodge obstacles, and rack up high scores. Simple concept. Deceptively deep mechanics.

But here's what shocked me: building it forced me to solve real game dev problems that textbooks don't teach you.

Lesson 1: Player Feedback Matters More Than Graphics

I spent my first two weeks obsessing over ship sprites, enemy designs, and visual polish. Then I played my own game.

It was hard to tell if I was hitting enemies. The feedback loop was broken.

So I added screen shake on hits, enemy death explosions, and visual hit markers. Suddenly, players felt connected to the action. It wasn't prettier — it was clearer. And clearer = more engaging.

Lesson: In game dev, a player who feels the impact of their actions stays longer than a player who sees a pretty explosion.

Lesson 2: Difficulty Curves Are Everything

My first version had waves of enemies that scaled way too fast. Players quit after 90 seconds.

I rebuilt the difficulty curve to ramp slower, with strategic windows of breathing room. Now players play for 5-10 minutes before getting overwhelmed.

Small change. Massive impact on player retention.

Lesson 3: Constraints Force Creativity

Browser games have hardware limits. You can't render thousands of particles. You can't load massive asset packs.

But that's where the fun lives. I used procedural patterns instead of complex sprites. Simple geometry instead of detailed models. And the game feels tighter because of it.

The best indie games I've played have tight constraints. They force you to be intentional with every design decision.

Lesson 4: Free Is a Marketing Superpower

I released Neon Starfighter for free. No ads. No paywalls.

Within two weeks, it had 5,000+ plays. People shared it. It got featured on indie game forums. Players emailed me feedback.

A free game is a conversation starter. It's a portfolio piece. It's a trust signal that you care about craft, not just conversion.

What Changed Everything

The real moment came when I watched a stranger play my game. They made it to wave 5, lost, and immediately restarted. That loop — play, lose, try again — is the core of game design. Everything else supports it.

That's when I realized: game dev isn't about building features. It's about designing experiences.

Try It

Neon Starfighter runs in your browser. No signup. No download. Just hit play.

Play Neon Starfighter: Overdrive

If you're curious about game dev, indie projects, or how constraints breed creativity, give it a spin. And if you build something yourself? I'd love to hear what you learn.

Building in public. One game at a time.

Why Most Traders Fail (And How a Simple Trading Journal Changes Everything)

Tanishpaul — Fri, 10 Jul 2026 03:31:19 +0000

I've watched traders blow up accounts. Not because they're stupid or reckless — because they don't have a system.

They take 100 trades, make money on 40, lose money on 60, and then blame "the market." But here's the thing: they have no idea which setups actually work. They don't see patterns. They're just gambling with conviction.

That's where a trading journal changes everything.

The Pattern Nobody Sees

Most traders remember their winners. Your brain is wired that way. You remember the +5% day. You forget the -3% day that came right before it.

But the losing day? It had a setup. Entry signal. Exit trigger. And it failed because of something specific — maybe you entered too early, maybe the risk/reward was off, maybe you missed a resistance level.

Without a journal, you'll make the same losing trade 50 times. With a journal, you see it on the 2nd time and never do it again.

What a Trading Journal Does (That a Spreadsheet Can't)

Yes, you could use Excel. But:

Excel doesn't force structure — you'll miss entries, skip notes, forget to log losses
Excel doesn't analyze patterns — you're manually hunting for them
Excel doesn't give you feedback — a good journal shows you your win rate by setup, your best times of day, your worst market conditions

A real trading journal:

Forces discipline — every trade gets logged
Highlights patterns — which setups work in which conditions
Removes emotion — you see data, not feelings
Builds confidence — you know exactly what works

The Setup That Changed My Trading

I was a breakout trader. Good setups, terrible execution. Entry too early, exit at the first sign of weakness.

The journal showed it: -2.5% average per breakout trade. That's a losing edge.

But my reversals? +1.8% average. I'd never noticed because I only remembered my winning breakouts.

Once I saw that in the data, I stopped breakout trading entirely. Now I wait for reversals.

That one insight from my journal (based on 6 months of data) added 2% to my annual return. Just by seeing what actually works.

The Cost of Not Keeping a Journal

Imagine paying money to learn lessons you've already paid for.

Every losing trade you repeat is money out of your pocket. Again.

A trader who journals learns faster, adapts smarter, and stops losing the same way.

Start Today

You don't need a fancy journal. You need:

Entry date & time
Setup type (breakout, reversal, support bounce, whatever)
Entry price & exit price
P&L
Notes — what went right, what went wrong

Do that for 30 trades. Look at the data. I guarantee you'll see at least one pattern that's costing you money.

Ready to see your trading patterns? TradesLog is built exactly for this — simple logging, instant insights, no spreadsheets.

Start your free trading journal today.

I Replaced Manual Data Entry With AI — Here's Exactly How It Works

Tanishpaul — Thu, 09 Jul 2026 03:32:00 +0000

I Replaced Manual Data Entry With AI — Here's Exactly How It Works

TL;DR: Manual data entry is costing small businesses thousands of hours per month. I built DataSwift AI to replace it entirely — and here's exactly how it works.

The Problem With Manual Data Entry

Every day, somewhere right now, someone is sitting at their computer typing invoice numbers into a spreadsheet.

It's 2026. We have AI that can write essays, code entire applications, and hold conversations. But millions of people are still manually extracting data from PDFs, scanned documents, and emails.

Why?

Because most "automation" tools either:

Cost $50-500 per month regardless of how much you use them
Require custom training for every document type
Spit out messy, unstructured data you have to clean anyway
Get it wrong 30% of the time

The cost? A small business processing just 100 invoices a day loses roughly 200 hours per month to manual data entry. That's $20,000+ in wasted labor costs annually.

How DataSwift AI Works (And Why It's Different)

I started building DataSwift AI because I watched my accountant friend manually type invoice data into QuickBooks for 6 hours a day. That's when I realized: we don't need better data entry software. We need to eliminate data entry entirely.

Here's the workflow:

Step 1: Upload Your Document

You upload any document type — invoices, receipts, contracts, loan forms, insurance claims, bank statements, anything with structured data.

Step 2: AI Extracts & Structures the Data

Our AI doesn't just OCR the text. It understands the document structure, identifies key fields, and extracts them with 99.2% accuracy. No training needed. It works on Day 1.

Step 3: Export to Your System

Export directly to your CRM, accounting software, database, or spreadsheet. Clean, structured, ready to use.

No subscription. No contracts. You pay per document processed.

A small business processing 500 invoices/month pays roughly $25-50. A large enterprise processing 10,000 invoices/month pays $500-1000. That's a 90% cost reduction vs traditional SaaS tools.

The Math: Why This Actually Saves Money

Let's say you process 200 invoices per month:

Manual entry cost:

2 hours/day × 20 workdays = 40 hours/month
@ $25/hour = $1,000/month in labor

DataSwift AI cost:

200 documents × $0.10/doc = $20/month
+ 15 minutes of human review = ~$6/month
Total: ~$26/month

You save $974 per month. That's $11,688 per year on just 200 invoices.

And that's before accounting for the errors that slip through manual entry — missing data, transposed numbers, duplicate entries.

Why I Built This as "Pay Per Document"

Everyone asked: "Why not charge a subscription?"

Because subscriptions punish your users for being cautious. If you're a small business testing a new tool, you don't want to commit to $99/month. You want to process 10 documents, see if it works, then scale up.

With DataSwift AI, your first 100 documents might cost $10. If it saves you 50 hours, you're getting $1,250 of value for $10.

That's a bet most teams are willing to take.

What Document Types Can You Use?

I started with invoices, receipts, and W2s. But the AI works on virtually any semi-structured document:

Finance: invoices, receipts, bank statements, tax forms
HR: employment contracts, offer letters, expense reports
Legal: NDAs, loan agreements, insurance documents
Logistics: shipping labels, packing slips, purchase orders
Real estate: rental agreements, property deeds, inspection reports

Where This Is Headed

Right now, DataSwift AI handles 95% of common business documents. The next phase is building fine-tuned models for industry-specific documents (medical records, construction permits, etc.).

But the core insight stays the same: people shouldn't spend their time typing data from documents. That's a solved problem. Let AI do it.

Try It Yourself

Upload any document right now to https://dataswift-ai.netlify.app — no signup required, no credit card needed.

See exactly how the extraction works. See the accuracy. Then decide if it's worth cutting 50+ hours out of your monthly workload.

Because 2026 is too late to still be doing manual data entry by hand.

I Made a Cyberpunk Idle Game About Doomscrolling — And It's Uncomfortably Accurate

Tanishpaul — Wed, 08 Jul 2026 03:31:06 +0000

I Made a Cyberpunk Idle Game About Doomscrolling — And It's Uncomfortably Accurate

I spent 3 months building an idle game about phone addiction. The premise is uncomfortably simple: what if doomscrolling actually built a cyberpunk empire?

The Concept

Doomscroll 2077 is a free browser idle game where you:

Mine data from infinite scrolling feeds
Extract AURA (the game's currency) from your digital footprint
Build a dystopian data empire
Prestige and restart to grow faster

No download. No signup. No ads. Just play.

Why I Built This

Most indie games try to be respectful of your time. Doomscroll 2077 is the opposite — it's a game about respecting your time by making fun of how little we do.

I started with a question: What if the thing we hate about our phones was actually the most engaging game mechanic ever invented?

The infinite scroll is addictive by design. YouTube knows it. TikTok knows it. Instagram definitely knows it. So instead of fighting it, I built a game around it.

The Game Loop

The core mechanic is dead simple:

Tap to generate data (doomscroll)
Watch numbers go up (oddly satisfying)
Unlock new features
Prestige and restart
Repeat forever

But hidden beneath the idle veneer is an actual economy:

Data: The raw resource. Scrolling generates it.
AURA: Processed data. More valuable, but requires upgrades.
Prestige: Reset and climb faster. The classic idle game twist.

The Uncomfortably Accurate Part

The game does something that made me uncomfortable while building it: it makes doomscrolling fun.

Not in a harmful way. But there's something about turning your phone addiction into a game that makes you go, "Wait... is this a metaphor for what I actually do?"

The answer is yes. And that's the entire joke.

Why It Works

Low barrier to entry: Load the page, tap once, you're playing.
No attention tax: You can walk away. It ticks in the background.
Real progression: Unlike actual doomscrolling, your progress matters.
Dark humor: The cyberpunk aesthetic gives doomscrolling a dystopian edge.

The Response

Since launch, players have spent hours in this game about... not spending hours on their phones. The irony is not lost on me.

But here's what I learned: people don't hate time-wasters. They hate pointless time-wasters. Give them a game where watching numbers go up equals progress, and they're all in.

Built with No Paywalls

I made Doomscroll 2077 completely free because:

Ads would ruin the vibe
I didn't want to gate features
The best marketing for a SaaS founder isn't a SaaS — it's something people actually want to tell their friends about

Play It

🎮 Play free: https://doomscroll2077.netlify.app

📦 Also on itch.io: https://blueauric-studio.itch.io/doomscroll-2077

No download. No signup. Just open, tap, and watch your empire grow.

I'm building in public as a solo founder from India. Doomscroll 2077 is one of four products I've shipped this year. If you build games or SaaS tools, I'd love to connect.

gamedev #indiegame #cyberpunk #buildinginpublic #idle

From Invoice to Database in 10 Seconds — The AI Tool Small Businesses Need

Tanishpaul — Tue, 07 Jul 2026 03:31:16 +0000

From Invoice to Database in 10 Seconds — The AI Tool Small Businesses Need

Your business processes 50 invoices a day. Some weeks, more.

Right now, someone on your team is probably sitting at a desk, typing data from those PDFs into a spreadsheet or your accounting software. Name, amount, date, vendor, line items — manually, one by one.

It takes time. It introduces errors. And it's soul-crushing work.

What if those invoices could extract themselves?

The Problem Nobody Talks About

Manual data entry isn't just inefficient — it's expensive.

If your team member makes $15/hour and spends 2 hours a day on invoice data entry, that's $150 a day, $750 a week, $3,000 a month just typing numbers. Multiply that by 12 months and you're looking at $36,000 annually lost to manual work.

And that's before accounting for:

Errors: A single digit typo costs time to fix, and can cause accounting headaches
Delays: Your financial reports lag because data entry takes time
Frustration: Your team's morale drops doing repetitive work

Most businesses solve this by upgrading to "enterprise" accounting software. Cost: $2,000-5,000/month. For features you'll use 10% of.

There's a Better Way

I built DataSwift AI because I got tired of watching businesses throw money at this problem.

Here's how it works:

Upload any document — invoice, receipt, form, statement. PDF, PNG, JPG, doesn't matter
AI extracts instantly — vendor name, amount, date, tax, line items, everything
Export directly — to your CRM, database, spreadsheet, or accounting system
Pay only for what you use — no subscription, no monthly fee, just $0.50-2 per document

No more data entry. No more errors. No more wasted hours.

Why This Pricing Model Works Better

Traditional SaaS charges you $49/month whether you process 5 documents or 500.

DataSwift AI charges per document. Process 10 invoices one month? $5-20. Process 200 the next? $100-400. You pay exactly for what you use.

For a small business processing 100 invoices a month, that's $50-200 instead of $49 minimum. For companies processing 1000+ documents? You're saving thousands annually.

Real Use Cases

Accounting firms: Extract client documents instantly, cut data entry time by 90%

E-commerce businesses: Turn receipts and shipment docs into structured data for your inventory system

Freelancers & agencies: Invoice extraction for faster billing cycles and client handoff

Finance teams: Bank statements, expense reports, loan documents — all extracted in seconds

The Math

Assume you process 100 invoices/month:

Old way (manual entry at $15/hr, ~1.5 min per invoice):

100 invoices × 1.5 min = 150 minutes = 2.5 hours
2.5 hours × $15/hr = $37.50/month in labor

Subscriptionware ("smart" invoice software):

$49-199/month, plus setup time, plus learning curve

DataSwift AI:

100 invoices × $1.50/avg = $150/month
But you save 2.5 hours of your team's time (that's $37.50 in labor, plus freed-up capacity)
Net cost? Practically zero. You're investing in speed and accuracy

Who's Building This?

I'm Tanish, a solo founder building this from India. I've been frustrated by document-heavy workflows for years, and I got tired of waiting for someone else to fix it.

I'm building this in public because transparency matters. You can watch the roadmap, give feedback, and help shape what gets built next.

Try It Free

No credit card. No sign-up hell. Just upload a document and see it extract.

Upload an invoice to DataSwift AI — takes 30 seconds and you'll see exactly what I mean.

If you're processing invoices, receipts, or any documents manually, this is for you.

What's Next?

DataSwift AI is built for small teams and freelancers right now. Next on the roadmap:

Bulk upload (50+ documents at once)
Scheduled extraction (drop files in a folder, they extract automatically)
Webhook support (send extracted data directly to your app)
Crypto payments (for international builders)

Want early access to new features? Drop your email when you sign up — you'll be first to know.

Building in public. No BS. Just shipping.

buildinginpublic #AI #SaaS #Automation #SmallBusiness