DEV Community: Chris Joy

Building My Own Automated Budget Tracker Using Notion

Chris Joy — Mon, 29 Dec 2025 21:41:25 +0000

I'll be honest: I never thought I'd ditch Xero. It's the industry standard, right? Every accountant recommends it. But after years of dealing with clunky interfaces, limited reporting flexibility, and watching my subscription cost creep up year after year, I started questioning whether I really needed all of Xero's features—or if I was just paying for vendor lock-in.

The breaking point came when I realized I was maintaining two separate systems: Xero for my financial data, and Notion for literally everything else in my business. I had project docs in Notion, client notes in Notion, strategic planning in Notion—but my financial dashboard was stuck in Xero's rigid reporting interface. Every time I needed to combine financial metrics with other business data, I was exporting CSV files and manually piecing things together.

That's when I discovered BankSync. It's not trying to be Xero—it's something better. It's the data layer that syncs your bank transactions, account balances, and receipts directly into the tools you already use. For me, that's Notion. And the switch has completely transformed how I handle my business finances.

Why I Left Xero

Before I dive into how BankSync works, let me explain what drove me away from Xero in the first place.

1. Limited Customization

Xero's reports are... fine. They're predefined, polished, and probably work great if your business fits into their template. Mine doesn't. I wanted to build custom dashboards that combined financial data with project milestones, client retention metrics, and revenue forecasts. Xero couldn't do that. Every time I tried to customize a report, I hit a wall.

With Notion, I can build literally any view I want. I can create formulas, relations, rollups—I can make my financial data dance. But only if I could get the data into Notion in the first place.

2. Annual Price Hikes

Let's talk about pricing. When I first signed up for Xero, I was paying $15/month for the Starter plan. That seemed reasonable. But every year, like clockwork, the price went up. By year three, I was paying closer to $20/month for the same features. And if I wanted more advanced reporting? That would be $37/month or more. Plus, they were constantly pushing upsells and add-ons.

BankSync costs $7/month. That's it. No hidden fees, no annual increases, no pressure to upgrade. For a solo founder watching every dollar, that difference matters.

3. Vendor Lock-In

This was the big one. My financial data was trapped in Xero's ecosystem. Sure, I could export it, but that meant manual work every single time. And once it was out of Xero, I was dealing with messy CSV files that didn't integrate with anything.

I wanted my data to live in my tools—tools I own and control. Tools that aren't going to suddenly change their pricing model or sunset features I depend on. I wanted data portability, and Xero wasn't giving me that.

4. I Didn't Need Full Accounting Features

Here's the thing: I'm a freelancer and small business owner. I don't need invoicing (I use Stripe for that). I don't need payroll (it's just me). I don't need inventory management (I sell services, not products). What I needed was simple: automatic transaction syncing, receipt tracking, and the ability to build my own reports.

Xero was overkill. I was paying for a Ferrari when all I needed was a reliable Honda.

How BankSync Works (And Why It's Better for My Workflow)

BankSync isn't accounting software. It's a data layer that connects your banks to your Work OS—whether that's Notion, Airtable, or Google Sheets. Here's what it does:

Bank Feeds: Automatic Transaction Syncing

Just like Xero, BankSync connects to 10,000+ banks using secure OAuth 2.0 authentication. Once connected, it automatically syncs transactions, account balances, and even investment holdings to your destination of choice.

For me, that destination is Notion. I created a "Transactions" database with columns for Date, Merchant, Amount, Category, and Notes. BankSync syncs new transactions daily, and they just... appear. No manual entry, no CSV imports, no copy-pasting. It's seamless.

The difference from Xero: Instead of logging into a separate app to view my transactions, they're right there in my Notion workspace alongside my projects, clients, and goals. I can link transactions to specific projects, tag them with custom properties, and build views that Xero could never support.

Receipt Extractor: AI-Powered OCR That Actually Works

This feature alone justified the switch for me. BankSync's receipt extractor uses AI-powered OCR to automatically extract data from receipts and sync it to Notion.

Here's how it works:

Email Forwarding: BankSync gives you a unique email address (like receipts-abc123@receipt.banksync.io). Whenever I get a receipt email—from Amazon, Home Depot, Uber, wherever—I just forward it to that address.
AI Extraction: BankSync's AI reads the receipt (even from attachments like PDFs or images) and extracts all the important data: merchant name, date, total amount, tax, line items, and even the receipt image itself.
Automatic Sync: All that data gets synced to my Notion "Receipts" database automatically. No manual entry, no typing, no mistakes.

The extraction accuracy is insane—I'd estimate 95%+ success rate. And when there are minor errors, I can just fix them directly in Notion.

The Xero comparison: Xero has receipt capture, but it's nowhere near this smooth. You have to use their mobile app, manually snap photos, and hope the OCR works. With BankSync, I'm just forwarding emails I'm already getting. Zero friction.

Email Verification Forwarding: The Detail That Matters

This might sound like a small thing, but it's incredibly thoughtful. When you set up email forwarding (like forwarding receipts from Gmail to BankSync), your email provider (Gmail, Outlook, etc.) sends a verification email to confirm the forwarding address.

The problem: That verification email gets sent to BankSync's inbox, not yours. So you never see the verification code.

BankSync's solution: Their system automatically detects verification emails, extracts the verification code or link, and forwards it back to you with a beautifully formatted email explaining what's happening.

Unlike Xero, which doesn't even support this kind of workflow, BankSync handles the edge cases. It's the kind of attention to detail that makes me trust the product.

Notion Integration: Total Flexibility

The real magic happens in Notion. Because my financial data now lives in Notion databases, I can:

Create custom dashboards with monthly expense summaries, year-over-year comparisons, and spending trends
Link transactions to projects to track profitability on a per-client basis
Build automated workflows using Notion formulas and relations (e.g., "Flag any transaction over $500 for review")
Combine financial and business data in ways Xero could never support

For example, I have a "Projects" database in Notion. Each project has a relation to my "Transactions" database, so I can see exactly how much I've spent on that project in real-time. I can also see which expenses are still missing receipts, which ones are tax-deductible, and how they impact my overall budget.

This kind of customization is impossible in Xero. Their reports are rigid, and their integrations with other tools are clunky at best.

The Migration: Easier Than I Expected

Switching from Xero to BankSync took me about an hour. Here's what I did:

Step 1: Export Historical Data from Xero

I exported my chart of accounts, transaction history, and key reports from Xero as CSV files. This gave me a baseline to import into Notion if I needed historical context.

Step 2: Set Up My Notion Databases

I created two main databases in Notion:

Transactions Database: Columns for Date, Merchant, Amount, Category, Account, and Notes
Receipts Database: Columns for Date, Merchant, Amount, Tax, Category, Receipt Image, and Attachments

I used one of Notion's budget templates as a starting point and customized it to fit my needs. Total setup time: about 20 minutes.

Step 3: Connect My Banks to BankSync

I logged into BankSync, connected my business checking and savings accounts (using the same banks I had in Xero), and mapped the transaction fields to my Notion database columns. BankSync's field mapping interface is intuitive—way easier than Xero's initial setup, honestly.

Step 4: Set Up Receipt Extraction

I created a receipt extractor in BankSync, mapped the extracted fields to my Notion "Receipts" database, and got my unique forwarding email address. Then I set up a Gmail filter to automatically forward receipt emails to BankSync. Now, whenever I get a receipt from Amazon, Stripe, or any vendor, it's automatically processed and synced to Notion.

Step 5: Configure Automatic Syncing

I set BankSync to sync transactions daily at 6 AM. Every morning, when I open Notion, my transactions from the previous day are already there, categorized and ready to review.

That's it. No complicated migration scripts, no data loss, no headaches. Just a straightforward setup process.

What I Gained by Switching

1. Complete Data Ownership

My financial data now lives in Notion—a tool I control. I can export it, back it up, and move it anywhere I want. No vendor lock-in, no proprietary formats.

2. Radical Flexibility

I can build any report, dashboard, or workflow I can imagine. Want to see monthly spending by category? Done. Want to link expenses to specific clients and calculate per-project profitability? Easy. Want to combine financial data with my marketing metrics and OKRs? No problem.

Xero couldn't do any of this without third-party integrations and workarounds.

3. Massive Cost Savings

I went from paying $20/month for Xero (with annual increases) to $7/month for BankSync. That's $156/year in savings. As a bootstrapped founder, that money goes back into growing my business.

4. Investment Tracking

This was a bonus I didn't expect. BankSync supports full investment account tracking—holdings, trades, balances, and trade history. Xero barely touches investment data. Now I can see my entire financial picture (operating accounts + investments) in one place.

5. Peace of Mind

No more dreading Xero's clunky interface. No more fighting with rigid reports. No more worrying about price hikes. My finances are now part of my daily Notion workflow, and it feels effortless.

What I Miss About Xero (Spoiler: Not Much)

I'll be honest—there are a few things Xero does that BankSync doesn't:

Invoicing: Xero has built-in invoicing, but I use Stripe for that anyway, so it wasn't a loss for me.
Tax Preparation: Xero has integrations with tax software and accountant collaboration features. I work with an accountant who's perfectly happy with my Notion exports, so this hasn't been an issue.
Multi-Entity Accounting: If you're managing multiple legal entities or complex accounting scenarios, Xero's structure might be necessary.

But for me—a solo founder who just needs transaction syncing, receipt tracking, and flexible reporting—I don't miss Xero at all.

Who Should Make This Switch?

BankSync is perfect if you:

Already use Notion, Airtable, or Google Sheets for your business operations
Don't need full accounting features (invoicing, payroll, inventory)
Want complete control over your financial data and reporting
Are frustrated with Xero's pricing, performance, or rigidity
Value data portability and flexibility over all-in-one solutions
Need investment account tracking alongside your operating accounts

If you need comprehensive accounting features or your accountant requires Xero, then stick with Xero. But if you're like me—tired of vendor lock-in and ready to build a financial system that actually fits your workflow—BankSync is a game-changer.

Final Thoughts

The financial technology landscape is shifting. We're moving away from monolithic, closed-loop accounting systems and toward modular data layers that integrate with the tools we already use. BankSync represents that future.

By replacing Xero with BankSync, I didn't just save money. I gained control over my financial data, eliminated vendor lock-in, and built a system that actually works the way I think. My transactions, receipts, and reports now live in Notion—right alongside my projects, goals, and strategic planning.

It's not just a better workflow. It's the workflow I should have had all along.

If you're ready to take control of your financial data and ditch the accounting software bloat, give BankSync a try. The 14-day free trial is enough to see if it fits your workflow. And trust me—once you see your bank transactions syncing automatically into Notion, you won't want to go back.

Automating My Budget Tracker in Notion with AI + BankSync

Chris Joy — Sat, 27 Sep 2025 01:19:48 +0000

TL;DR: I built a budget tracker in Notion that imports transactions via BankSync and uses AI to categorize them, based on how I tagged them previously. It cut my monthly budget review from ~2 hours to about 5 minutes.

Why I Did This

Every month, I was spending 2+ hours sorting and categorizing transactions. I tried apps like Mint or YNAB, but I always felt constrained by their rigid setups. Meanwhile, I manage nearly everything in Notion—so why not my finances, too?

Plus, there’s a Notion template to help you get started: the Cash Flow Tracker (with Live Banking Data) from BankSync. It gives you a structure and database where your transactions can automatically flow in and feed into dashboards.

View the template

How I Imported My Bank Data via BankSync (And Yes, You Can Too)

This was the crucial “glue” step that made all the automation possible. I’ll walk you through how I set it up, with links to the official BankSync guides so you can follow along exactly.

1. Connect Your Banks to BankSync

In BankSync, I added my bank accounts (checking, credit cards, etc.) using their secure connection flow.

Official guide: Connecting Your Banks

2. Authorize Notion Integration

After connecting banks, I went to the “Destinations / Integrations” section in BankSync and added Notion. This lets BankSync push transaction data to a Notion database of my choice.

Official guide: Setting Up Notion Integration

In Notion, you’ll also sometimes need to “Add connection” on the specific page where you want the data to land (so the integration has permission).

See Notion’s guide on managing connections: Add & Manage Integrations (Notion Help Center)

3. Create Your First Sync & Field Mapping

With banks and Notion connected, it's time to create your first “sync” — mapping which bank → which Notion database, and connecting the fields (merchant, amount, date, etc.).

Official guide: Creating Your First Sync

You’ll also use BankSync’s field mapping guide to precisely map how each piece of data should land in your Notion columns.

Official guide: Field Mapping Configuration

4. Configure Scheduled Syncs (Optional but Handy)

Once the sync is working, you can set BankSync to update periodically (e.g. hourly or daily), so you don’t have to manually push data.

Official guide: Scheduling Syncs

5. Manage & Monitor Sync Jobs

As your data flows, you'll want to keep an eye on sync jobs — checking for failures, duplicates, or mismatches.

Official guide: Managing Sync Jobs

6. Initial Cleanup & Ongoing Monitoring

After the first import, I cleaned up formatting (dates, decimals), removed any duplicates, and confirmed all fields showed up correctly in Notion. From then on, new transactions flowed in automatically, and I mostly just monitor “edge cases.”

The Setup in Notion

With BankSync feeding data in, here’s what I built next:

A Transactions database (imported fields: description, date, amount, account)
A Category field (type: Select)
An AI Category field (Formula / Notion AI)
Views like Auto-Tagged, Needs Review, New Transactions
Dashboard pages that roll up spending by category, month, etc.

AI Categorization: The “Magic” Formula

I crafted a formula prompt that asks Notion AI:

Based on similar transactions I've already categorized in this database, what category should this be?

Look at patterns:

Exact merchant names

Slight name variants (e.g. “Starbucks #1234”)

Amount ranges at a given merchant

Timing (weekend vs weekday)

Return a single category name matching my past tags.

If confidence < 80%, return "NEEDS REVIEW" so I can double-check manually.

Over time, it learns the rules I implicitly apply:

Starbucks → Coffee
Target under $50 → Groceries; over $100 → Shopping
$15.99 recurring → Netflix
Gas stations → Transportation

In Real Life: Accuracy & Workflow

Week 1: ~70–80% correct. I reviewed all suggestions.
Month 1: It starts understanding my amount & merchant patterns.
Month 3: ~95% accuracy. Now, I spend ~5 minutes on the “Needs Review” items.

Dashboard Views

Auto-Tagged — AI Category = Category
Needs Review — AI returned “NEEDS REVIEW”
New Transactions — Category is still unassigned

When AI Gets It Wrong (and What I Do About It)

Problem: AI labels my grocery store as “Shopping”

Fix: Manually tag ~5–10 transactions from that store as “Groceries” to teach it correct context

Problem: Everything shows “NEEDS REVIEW”

Fix: Start with broad categories (e.g. “Food” instead of “Organic Groceries”) so AI doesn’t overthink

Problem: AI is overly confident but wrong

Fix: Add more examples (including negative cases) and occasionally force “NEEDS REVIEW” to keep it honest

What I’ve Gained

5 minutes each Sunday to review (vs ~90 minutes before)
87% auto-tagged correctly after first month
3 “that’s clever” moments per week
Zero dread on budget review day

My Sunday Routine Now

Open the Needs Review view
Quickly accept good AI suggestions
Manually tag weird or ambiguous transactions
Done — done ✅

Then: coffee, walk, or whatever feels fun.

Lessons Learned

Start broad (you can split categories later)
Your own past data is the best teacher
Don’t be shy to correct mistakes — that’s how the model refines
Simplicity wins — you can add nuance later

The Bottom Line

This setup won’t fix all financial stress, but it will eliminate the part I hated the most: categorizing transaction after transaction. Swapping ~2 hours of busy work for a 5-minute habit is absolutely worth it to me.

What’s your biggest budgeting pain point? Has anyone else tried automating transaction categorization? I’d love to compare workflows!

Using Feature Flags to decouple Deployments from Releases

Chris Joy — Tue, 28 Mar 2023 01:28:02 +0000

In regular software development, new features and updates are released to everyone at once. But that can cause some issues, like introducing bugs that can mess up the user's experience. It can also be tough to test and make new features work perfectly before they go live.

Feature flags fix these problems! They let developers release new features to certain groups of users or gradually turn them on. This way, they can test and make features better before everyone gets them, making it less risky and smoother for everyone.

Traditional Deployment Strategies

Deployments are super important in software development! They're all about moving code from one place to another, like from a testing area to the final product. Some ways people used to do deployments were through things like Git flow, which is a branching strategy.

Git Flow

Git flow is a cool way that developers can manage their code and deployments. It works like this: they create separate branches for different features they're working on, and then merge them into the "develop" branch. This branch has all the newest feature changes, and they can send it to a testing area (called "staging") to make sure everything works right.

Sometimes, there are bugs that need to be fixed right away without having to wait for the next update. That's where hotfix branches come in! They're like a shortcut that helps developers fix issues quickly and without having to wait for the next big update.

Once everything is good to go, the "release" branch has the most stable version of the app, which is what users will see. This way, everyone can be sure they're using a version that works well.

Using Git flow for deployments is better than just sending things straight to the finished product. But there are still some issues. Fixing things with hotfixes can take time, and it's important to make sure bad code doesn't get into the release branch and affect all users.

Hotfix branches are used to address bugs and help bypass the develop branch. This allows developers to quickly fix issues without having to wait for the next release cycle.

The release branch contains the most stable version of the application and is what is released to users. This ensures that users always have access to a stable version of the application.

Git flow-based deployments solves the problem of deploying directly to production, which could introduce bugs and other issues. However, it has its own problems. Hotfixes take time to fix and merge into the release branch, then re-deploy. All users would be affected if the release branch has some bad code.

Traffic Splitting Strategies

To tackle these challenges, traffic splitting strategies have become more popular. This involves directing the flow of users between different versions of an application. This way, developers can test out new features and fixes without affecting all users at once. It's a way to try things out and make sure everything is working smoothly before making it widely available.

Blue/Green Deployment

In a Blue/Green deployment, developers create two completely separate environments that are identical: one is the Blue environment, which runs the current application version, while the other is the Green environment, which runs the new version of the application.

To test out new features or fixes before making them available to all users, traffic is directed between the two identical environments in a Blue/Green deployment. However, this strategy still has a downside: if there's any bad code in either environment, all users will be affected. Even if it's just one new feature causing an issue, developers would still have to roll back all the features that were released.

Canary Deployment

To address the problem of rolling back all features in a Blue/Green deployment, developers use a Canary deployment strategy. This involves gradually rolling out a new version of the service to a small group of users first. This way, they can test out new features on a small subset of users before making them available to everyone. This strategy minimizes the risk of introducing bugs or other issues and allows developers to make sure everything is working properly before deploying the new version to all users.

Canary deployment has a lot of benefits over other deployment strategies, such as the ability to test out new features on a small group of users before rolling them out to everyone, reducing risk by catching issues early on, and allowing for more controlled rollouts by gradually increasing or decreasing traffic based on feedback and metrics.

However, it also has its own limitations. For example, it's not possible to independently test out features on different groups because features are released together in batches. This can make it harder to identify which features are causing issues or which ones are working well.

Introducing Feature Flags

Feature flags, also known as feature toggles or feature gates, are points in code that divide traffic and control which variation of a feature users are exposed to. They're typically used in conditional statements such as "if" statements.

Local Feature Store

A local feature store is a place where feature flag values are stored on the user's device. These values are often configurable by application users, which means users can enable or disable certain features based on their preferences. Examples of local feature stores include chrome://flags and firefox://about:config, which are settings pages within the Chrome and Firefox browsers respectively where users can toggle experimental features on and off.

One issue with local feature stores is that once an application is released to users, developers can no longer configure feature flags unless they release a new version of the application with updated flag values. This means that developers cannot easily change or test different feature variations without releasing a new update, which can be time-consuming and disruptive to users.

A remote feature store is a centralized location where flag values can be controlled remotely. This means that developers can modify feature flag values without having to release a new version of the application, and can target specific groups of users to see different features or experiences. Remote feature stores enable more dynamic and flexible control of feature flags, allowing developers to respond quickly to changes in user behavior or performance metrics.

It's important to keep in mind that feature flags should only be used temporarily and should be removed once they have served their purpose. Keeping a large number of feature flags can cause performance issues, as it increases the size of the flagset payload transmitted over the network into the application.

Feature flags do provide a solution to the problem of releasing features independently, as traffic splitting can be controlled per feature. This means that features can be released independently to a subset of users, allowing developers to test and optimize new features before releasing them to everyone.

Feature Management Platforms

There are many proprietary platforms available for managing feature flags, such as LaunchDarkly, ConfigCat, Split.io, StatsSig, and Rollouts.io. These platforms provide developers with a range of features and tools for managing feature flags, such as remote feature flag management, targeted rollouts, and A/B testing. They often offer integrations with popular development tools and frameworks, as well as advanced analytics and reporting capabilities. By using a feature flag management platform, developers can more easily control and manage feature flags, allowing them to release new features more efficiently and with greater control.

Absolutely! It's worth noting that there's also Flagbase, a free and open-source feature flag management platform. Flagbase is designed with performance in mind, and provides developers with the ability to manage feature flags easily and efficiently. With Flagbase, developers can control and manage feature flags remotely, target specific user groups, and conduct A/B testing, all for free. If you're looking for a feature flag management solution, be sure to check out Flagbase!

Here's a quick start guide: https://flagbase.com/docs/guides/quick-start/

That's a wrap! Happy Feature Flagging :D

In summary, feature flags are a valuable tool for developers to control the release of new features and target specific users. They enable the separation of feature releases from deployments, making it easier for developers to test and optimize new features before releasing them to everyone. With a feature management platform like Flagbase, developers can manage their feature flags more efficiently and keep their application performant. Regardless of which feature store is used, it's essential to remove feature flags once they've served their purpose. With these best practices in mind, developers can confidently roll out new features and improve their users' experiences. Happy coding!