Round raises $6M to automate the finance workflows that still require a human to press a button

Introduction

In today's fast-paced financial world, automation is becoming essential for businesses to stay competitive. This tutorial will teach you how to build a simple automated finance workflow system using Python and basic AI concepts. We'll create a system that can automatically categorize transactions, generate reports, and even suggest optimizations - all without requiring manual button presses. This is exactly the kind of automation that companies like Round are building to help financial teams work smarter.

Prerequisites

Before starting this tutorial, you'll need:

• A computer with Python 3.7 or higher installed
• Basic understanding of Python programming concepts
• Some familiarity with financial data concepts (transactions, categories, etc.)
• Access to a text editor or IDE (like VS Code or PyCharm)

Step-by-Step Instructions

Step 1: Set Up Your Development Environment

Install Required Python Packages

First, we need to install the packages we'll use for this project. Open your terminal or command prompt and run:

pip install pandas scikit-learn numpy

Why we do this: These packages provide the foundation for data processing, machine learning, and mathematical operations we'll need for our financial automation system.

Step 2: Create Your Project Structure

Set Up Your Project Folder

Create a new folder called finance_automation and inside it, create these files:

• main.py - Our main application file
• transaction_processor.py - Handles transaction data
• report_generator.py - Creates financial reports
• data_sample.csv - Sample transaction data

Step 3: Prepare Sample Financial Data

Create Sample Transaction Data

In your data_sample.csv file, add the following sample data:

date,description,amount,currency
2023-01-15,Starbucks Coffee,-12.50,USD
2023-01-16,Salary Deposit,2500.00,USD
2023-01-17,Amazon Purchase,-89.99,USD
2023-01-18,Netflix Subscription,-15.99,USD
2023-01-19,Electricity Bill,-85.25,USD
2023-01-20,Restaurant Dinner,-67.40,USD
2023-01-21,Office Supplies,-45.00,USD

Why we do this: Having sample data allows us to test our automation system without needing real financial data, which is important for learning purposes.

Step 4: Build the Transaction Processor

Create the Transaction Processing Module

In transaction_processor.py, add this code:

import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB

# Sample transaction data
transactions = [
    {'description': 'Starbucks Coffee', 'category': 'Food & Dining'},
    {'description': 'Netflix Subscription', 'category': 'Entertainment'},
    {'description': 'Electricity Bill', 'category': 'Utilities'},
    {'description': 'Amazon Purchase', 'category': 'Shopping'},
    {'description': 'Office Supplies', 'category': 'Business'},
]

class TransactionProcessor:
    def __init__(self):
        self.vectorizer = TfidfVectorizer()
        self.classifier = MultinomialNB()
        self._train_classifier()

    def _train_classifier(self):
        # Prepare training data
        descriptions = [t['description'] for t in transactions]
        categories = [t['category'] for t in transactions]
        
        # Vectorize descriptions
        X = self.vectorizer.fit_transform(descriptions)
        
        # Train classifier
        self.classifier.fit(X, categories)

    def categorize_transaction(self, description):
        # Vectorize new description
        X = self.vectorizer.transform([description])
        
        # Predict category
        prediction = self.classifier.predict(X)
        return prediction[0]

    def process_transactions(self, file_path):
        df = pd.read_csv(file_path)
        
        # Add category column
        df['category'] = df['description'].apply(self.categorize_transaction)
        
        return df

Why we do this: This module uses basic machine learning to automatically categorize transactions. The system learns from examples and can then categorize new transactions without manual input.

Step 5: Create the Report Generator

Build Financial Report Functionality

In report_generator.py, add this code:

import pandas as pd
from datetime import datetime

def generate_summary_report(df):
    # Calculate total expenses and income
    total_expenses = df[df['amount'] < 0]['amount'].sum()
    total_income = df[df['amount'] > 0]['amount'].sum()
    
    # Group by category
    category_summary = df.groupby('category')['amount'].sum().sort_values(ascending=False)
    
    # Generate report
    report = {
        'generated_date': datetime.now().strftime('%Y-%m-%d'),
        'total_expenses': abs(total_expenses),
        'total_income': total_income,
        'net_flow': total_income + total_expenses,
        'category_breakdown': category_summary.to_dict()
    }
    
    return report


def print_report(report):
    print(f"Financial Report Generated on {report['generated_date']}")
    print("=" * 50)
    print(f"Total Income: ${report['total_income']:.2f}")
    print(f"Total Expenses: ${report['total_expenses']:.2f}")
    print(f"Net Flow: ${report['net_flow']:.2f}")
    print("\nCategory Breakdown:")
    
    for category, amount in report['category_breakdown'].items():
        print(f"  {category}: ${abs(amount):.2f}")

Why we do this: This component automatically generates financial summaries, which is exactly what automated finance systems do to save time and reduce human error.

Step 6: Create the Main Application

Put Everything Together

In main.py, add this code:

from transaction_processor import TransactionProcessor
from report_generator import generate_summary_report, print_report

# Initialize processor
processor = TransactionProcessor()

# Process transactions
print("Processing transactions...")
transactions_df = processor.process_transactions('data_sample.csv')

# Generate and display report
print("\nGenerating financial report...")
report = generate_summary_report(transactions_df)
print_report(report)

# Save processed data
transactions_df.to_csv('processed_transactions.csv', index=False)
print("\nProcessed data saved to 'processed_transactions.csv'")

Why we do this: This main file ties everything together, demonstrating how our automation system works end-to-end - from processing data to generating reports automatically.

Step 7: Run Your Automation System

Execute Your Financial Automation

Open your terminal, navigate to your project folder, and run:

python main.py

You should see output similar to:

Processing transactions...
Generating financial report...
Financial Report Generated on 2023-04-15
==================================================
Total Income: $2500.00
Total Expenses: $200.14
Net Flow: $2299.86

Category Breakdown:
  Business: $45.00
  Food & Dining: $12.50
  Entertainment: $15.99
  Utilities: $85.25
  Shopping: $89.99
  Salary Deposit: $2500.00

Processed data saved to 'processed_transactions.csv'

Why we do this: Running the system demonstrates that it works correctly and shows how it can automate tasks that would normally require manual effort.

Summary

In this tutorial, you've built a basic automated finance workflow system that can categorize transactions, generate reports, and save processed data - all without requiring manual button presses. This is the kind of automation that companies like Round are developing to help financial teams work more efficiently. While this example is simplified, it demonstrates the core concepts behind financial automation systems that are transforming how businesses manage their finances.

The system you've created uses basic machine learning for categorization and automated reporting, which are key components of modern financial automation platforms. As you continue to develop this system, you could add features like email notifications, more sophisticated categorization algorithms, or integration with real financial APIs.