User Story: How I Built My Own Invoice Payment Automation Without Being a Developer
Tomáš Doležal
Every month, I receive dozens of invoices that need to be paid, mostly via email as PDF attachments. To keep things organized, I created a simple system: I save all incoming invoices to a Google Drive folder named by month.
It works well until it's time to actually pay them.
That's when things used to get tedious. I had to open each file, extract the amount, account number, variable symbol, and notes, then copy everything into my banking interface to create a bulk payment file. I use two different banks, one for Czech koruna and one for Euro payments, and each has its own quirks and platform.
To make things even more complicated, I have a reporting system based on custom tags I add to the payment notes. It's great for tracking, but very impractical when entering everything by hand. One typo, a missed symbol, or a wrong number could mean a delayed payment or accounting error.
Eventually, I had enough.
My Goal Was Simple: No More Manual Work!
I wanted to completely automate the process, from the moment an invoice lands in my Drive folder to creating a bank-ready payment file. I didn’t want to touch it, review it, or stress over it. I just wanted it done accurately and reliably.
Since I work at BitSwan, where we build automation tools for data workflows, I thought: why not try it myself?
I'm not a developer, but I had access to BitSwan’s Jupyter Notebook environment and our internal AI Agent. Together, we started building the solution step by step.
AI had my back.
I opened a blank notebook and typed my goal: "I want to monitor a Google Drive folder, read new invoices, extract payment data, and create an XML file for batch payment via my bank’s API."
The AI agent understood the task and guided me through it.
First, we set up a webhook to watch the folder. BitSwan has many built in connectors for creating automations that interact with the outside world. Webhooks are only one of many ways a BitSwan automation can do so. Every time a new PDF is added, it triggers the next steps.
The flow looked like this:
- Detect invoice upload in Drive folder
- Extract data from PDF using AI
- Clean and format data to meet bank requirements
- Generate XML for bulk payment
- Send to the bank via API
- Mark invoice as “paid” in Drive
I learned how to use Python libraries like google-api-python-client, pandas, requests, and openai. The AI Agent, running on GPT-4o-mini, handled the data extraction part. It recognized variable symbols, account numbers, dates, and even parsed messy scanned PDFs into structured JSON. From there, the script created an XML file and submitted it through the bank’s API.
One of the best parts? The AI generated fully functional Python code to connect to the API, submit the file, and handle all the error checking. I didn’t write any backend code from scratch; I just reviewed what the agent provided, tested it, and adjusted based on real-world results. If I was programming traditionally I would have a lot of trouble understanding and trusting the code. But by using a Jupyter notebook I can test small bits of code independently and gain that trust bit by bit.
From Notebook to Real Automation.
Once everything was working, I hit “Deploy Automation” in the BitSwan Notebook. That one click turned the prototype into a real, production-ready automation.
Now, when I upload a new invoice into the folder, the automation runs in the background.
It reads the invoice from google drive.
It prepares the transaction.
I get a notification in my mobile banking app to approve the transaction.
Once approved, the payment is processed, and the invoice is automatically tagged as “paid.”
If I don't confirm the payment right away, the automation just waits for the next cycle and picks up where it left off.
The Change this had.
No more manual data entry. No more stress. No more errors from copy-pasting symbols or forgetting to tag payments properly. I save several hours every month, and I can fully trust that each invoice is processed accurately, with all reporting tags in place.
What used to be a repetitive, error-prone task is now a background process that runs smarter than I ever could.
And most importantly: I built this myself. Without being a developer. With help from AI and the right tools.
What I Learned?
This experience taught me the true power of combining automation, AI, and APIs.
Traditional code handles logic, structure, and control. AI helps extract meaning from unstructured data. APIs move that data into action.
Thanks to BitSwan’s clear interface and the power of our AI Agent, I never had to grapple with syntax or dependencies; I focused on solving my problem. I could test each step, inspect inputs and outputs, and iterate confidently.
If I had done this using “traditional” vibe coding I would have ended up with a mess of code that the AI produced and I did not understand or trust. But because BitSwan allows me to create the code in Jupyter notebook, breaking down the logic into smaller independently testable cells, I could play with and grow my solution confidently step by step, cell by cell. Even though I am not a programmer I can understand each step of the automation.
Another insight was that unlike many automation efforts this one is repeatable and adaptable. I started talking with clients, friends, and former colleagues and found many people with a similar but not identical invoice processing task. Thanks to the simplicity of the solution it is easy to modify and redeploy in other companies.
Final Thought.
It’s not just about saving time; it’s about working smarter with tools that put AI and automation in your hands. Once you see what's possible, you won’t want to go back.
"The automation runs. I stay focused."