Welcome to Keepfig

Your complete financial management platform. Track payments, manage expenses, and grow your business with confidence.

Getting Started

Your First Steps

Welcome! This guide will help you master Keepfig, even if you've never done accounting before. We'll explain not just how to use the features, but why they work the way they do and what they mean for your business.

Don't worry if terms like "debits," "credits," or "journal entries" sound foreign—we'll explain everything in plain English with real examples.

💡 What Makes Keepfig Different

Unlike spreadsheets or simple trackers, Keepfig uses proper accounting principles behind the scenes. This means:

  • Your books automatically balance
  • You can generate real financial statements
  • You're audit-ready from day one
  • You can scale from sole trader to enterprise

But here's the best part: you don't need to understand accounting to use it. Keepfig handles the complex stuff automatically.

Accounting Basics (Simple Explanation)

What Is Accounting, Really?

At its core, accounting answers three simple questions:

  1. What do I own? (Assets - cash, equipment, money owed to you)
  2. What do I owe? (Liabilities - loans, bills to pay)
  3. Am I making or losing money? (Revenue minus Expenses)

Everything in Keepfig revolves around tracking these three things accurately. When you record a payment, create an invoice, or log an expense, Keepfig updates all three automatically.

The Golden Rule: Every Transaction Has Two Sides

This is called double-entry accounting, and it's simpler than it sounds. Let's use a real example:

✅ Example: Customer Pays You ₦100,000

What actually happened?

  • Your cash increased by ₦100,000 (that's the first "entry")
  • Your revenue increased by ₦100,000 (that's the second "entry")

Why two entries? Because money doesn't appear from nowhere—it came FROM revenue and went INTO your bank account. Both sides need to be recorded.

What Keepfig does: When you record this as a "received payment," Keepfig automatically creates both entries in the background. You just fill in one form.

Why This Matters to You

You might be thinking: "Can't I just write '+₦100,000' in a spreadsheet?" Yes, but then:

Keepfig prevents these problems by maintaining the connection between "what happened" (revenue) and "where it went" (bank account).

Understanding Your Workspace

Keepfig organizes your financial data into workspaces (also called tenants). Think of a workspace as a complete set of books for one business entity. Each workspace is completely isolated, with its own:

Understanding Accounts

What Are Accounts? (And Why Should You Care)

An account in Keepfig is like a labeled bucket where you track specific types of money. Think of your business as having many buckets:

Every time money moves, it flows FROM one bucket INTO another bucket. This is how Keepfig tracks exactly where your money comes from and where it goes.

💡 Real-World Example

Let's say a customer pays you ₦50,000 for a website project:

  • ₦50,000 flows OUT of your "Revenue" bucket (because you earned it)
  • ₦50,000 flows INTO your "Bank Account" bucket (because that's where the cash landed)

Both buckets get updated. Your revenue goes up by ₦50,000, and your bank balance goes up by ₦50,000. This is why your books always balance!

Chart of Accounts: Your Complete List of Buckets

The Chart of Accounts is simply a list of all your buckets (accounts). It's organized into five main categories:

The Five Account Types Explained

1. Assets (Things You Own)

What they are: Anything of value your business owns or controls.

Common asset accounts:

How they increase: When you receive cash, buy equipment, or someone owes you money.
How they decrease: When you spend cash, sell equipment, or someone pays you back.

✅ Example: Buying a Laptop

You spend ₦300,000 on a new laptop for your business.

  • Bank Account (asset) decreases by ₦300,000
  • Equipment (also an asset) increases by ₦300,000

Your total assets stay the same—you just swapped cash for equipment.

2. Liabilities (Things You Owe)

What they are: Money or obligations your business owes to others.

Common liability accounts:

How they increase: When you borrow money, receive a bill, or owe someone.
How they decrease: When you pay back a loan or settle a bill.

⚠️ Example: Taking a Loan

You borrow ₦1,000,000 from a bank.

  • Bank Account (asset) increases by ₦1,000,000 (you now have more cash)
  • Loan Payable (liability) increases by ₦1,000,000 (you now owe the bank)

Your cash went up, but so did your debt. This is why both sides matter!

3. Equity (What's Truly Yours)

What it is: The difference between what you own (assets) and what you owe (liabilities). This is your true ownership stake in the business.

The equation: Assets - Liabilities = Equity

Common equity accounts:

Simple way to think about it: If you sold everything your business owns and paid off all debts, the equity accounts show how much you'd have left.

💡 Example: Starting Your Business

You invest ₦500,000 of your own money to start.

  • Bank Account (asset) increases by ₦500,000
  • Owner's Capital (equity) increases by ₦500,000

The business now has ₦500,000 in cash, and you own 100% of it.

4. Revenue (Money You Earn)

What it is: Income from selling products or services. This is how your business makes money.

Common revenue accounts:

Important: Revenue is recognized when you EARN it, not necessarily when you receive cash. If you send an invoice for ₦100,000, that's revenue even if the customer hasn't paid yet.

✅ Example: Completing a Project

You finish a ₦200,000 website project and send an invoice.

  • Accounts Receivable (asset) increases by ₦200,000 (customer owes you)
  • Service Revenue (revenue) increases by ₦200,000 (you earned it)

Later, when they pay:

  • Bank Account (asset) increases by ₦200,000
  • Accounts Receivable (asset) decreases by ₦200,000

Notice: Revenue was recorded once (when earned), even though cash came later.

5. Expenses (Money You Spend)

What they are: Costs of running your business. These reduce your profit.

Common expense accounts:

The Profit Formula: Revenue - Expenses = Profit (or Loss)

⚠️ Example: Paying Office Rent

You pay ₦50,000 for this month's rent.

  • Bank Account (asset) decreases by ₦50,000
  • Rent Expense (expense) increases by ₦50,000

Your cash went down, and your expenses went up. This reduces your profit for the month.

Managing Your Chart of Accounts

Viewing Your Accounts

1 Navigate to Accounts
Click "Accounts" in the left sidebar (under the Accounting section)
2 Browse by Type
Accounts are organized into the five types (Assets, Liabilities, Equity, Revenue, Expenses). Click a type to see all accounts in that category.
3 Check Account Balances
Each account shows its current balance. For example:
  • Bank Account: ₦2,500,000 (how much cash you have)
  • Sales Revenue: ₦5,000,000 (how much you've earned this period)
  • Rent Expense: ₦150,000 (how much you've spent on rent)

Creating a New Account

Keepfig comes with common accounts pre-configured, but you can add your own.

1 Click "New Account"
You'll see a form with these fields:
2 Fill in the details:
  • Account Name – Choose a clear, descriptive name (e.g., "Facebook Ads" instead of just "Marketing")
  • Account Type – Select from Assets, Liabilities, Equity, Revenue, or Expenses
  • Account Code – Optional numbering system (e.g., 1000 for assets, 4000 for revenue). Keepfig can auto-generate this.
  • Description – Optional notes about what this account tracks

💡 Account Naming Best Practices

  • Be specific: "Google Ads Expense" beats "Ads" if you use multiple platforms
  • Stay consistent: If you use "Expense" at the end, do it for all expenses
  • Think ahead: Will you understand this account name in 2 years?
  • Group related accounts: Use prefixes like "Bank - GTBank", "Bank - UBA" for multiple bank accounts

When to Create New Accounts

DO create a new account when:

DON'T create a new account when:

⚠️ Common Mistake: Too Many Accounts

New users often create way too many accounts. Having 50+ expense accounts makes reporting confusing. Start with broad categories, then split accounts only when you need detailed tracking.

Example: Start with "Marketing Expense." If later you're spending a lot and want details, split it into "Digital Ads," "Print Ads," and "Events."

Understanding Account Balances

Each account type behaves differently:

Account Type Normal Balance What "High Balance" Means
Assets Positive Good! You have more cash, equipment, or money owed to you.
Liabilities Positive You owe more money. Not necessarily bad if it's strategic debt.
Equity Positive Your ownership stake has grown. Good!
Revenue Positive You've earned more. Great!
Expenses Positive You've spent more. Watch this number!

✅ The Big Picture: How Accounts Connect

Here's how a typical business transaction flows through accounts:

  1. You provide a service → Revenue account increases
  2. Customer pays you → Bank Account (asset) increases
  3. You pay rent → Rent Expense increases, Bank Account decreases
  4. At month-end → Revenue minus Expenses = Profit, which increases Retained Earnings (equity)

Every account is connected. That's why your financial statements (Balance Sheet, Profit & Loss) always tell a complete story.

📚 Related Topics

Journal Entries: The Foundation

What Is a Journal Entry?

A journal entry is the actual record of a transaction showing the two accounts involved and the amounts. It's like a receipt that says "₦X moved from Account A to Account B."

Good news: Keepfig creates journal entries automatically for you. When you record a payment, expense, or invoice, Keepfig writes the journal entry behind the scenes.

💡 Example: What Happens When You Record a Payment

You record: "Customer paid ₦100,000"

What you see: A payment entry in your Payments list

What Keepfig does automatically:

Account Debit (Increase) Credit (Increase)
Bank Account (Asset) ₦100,000 —
Sales Revenue (Revenue) — ₦100,000

This journal entry links the two accounts and updates both balances.

Understanding Debits and Credits (Optional Deep Dive)

You don't NEED to understand debits and credits to use Keepfig—the system handles it automatically. But if you're curious:

The rules:

Account Type Increases With Decreases With
Assets Debit Credit
Expenses Debit Credit
Liabilities Credit Debit
Equity Credit Debit
Revenue Credit Debit

The golden rule: Total debits always equal total credits in every journal entry. This is why accounting is called "double-entry"—both sides must balance.

✅ Memory Trick: DEALER

Debits increase Expenses and Assets

Credits increase Liabilities, Equity, and Revenue

(The "C" in credits is silent, but you get the idea!)

Viewing Your Journal Entries

1 Navigate to Journal Entries
Click "Journal Entries" in the left sidebar (under Accounting)
2 Browse Entries
You'll see a list of all journal entries with:
  • Date – When the transaction occurred
  • Description – What the transaction was (e.g., "Payment from John Doe")
  • Total Amount – The transaction amount
  • Status – Usually "Posted" (finalized) or "Draft" (not yet finalized)
3 View Entry Details
Click any entry to see the full breakdown:
  • Which accounts were affected
  • Debit and credit amounts for each account
  • Any attached documents or notes

When to Create Manual Journal Entries

Keepfig automatically creates journal entries for standard transactions (payments, expenses, invoices). You rarely need to create them manually.

You MIGHT need a manual entry for:

⚠️ Warning: Be Careful with Manual Entries

Manual journal entries bypass Keepfig's built-in safeguards. If you enter the wrong accounts or amounts, you can throw off your reports.

Best practice: If you're unsure whether you need a manual entry, ask your accountant or reach out to Keepfig support. It's better to ask than to mess up your books!

Creating a Manual Journal Entry

Only use this if you're confident about what you're doing:

1 Click "New Journal Entry"
2 Enter Details:
  • Date – When did this transaction occur?
  • Description – Brief explanation (e.g., "Owner invested cash")
3 Add Entry Lines:
For each account affected:
  • Select the account
  • Enter the debit amount (if increasing an asset or expense)
  • OR enter the credit amount (if increasing a liability, equity, or revenue)
4 Ensure It Balances
Total debits must equal total credits. Keepfig will warn you if they don't match.
5 Save as Draft or Post
Save as Draft to review later, or Post to finalize the entry and update your accounts immediately.

✅ Example: Recording Owner Investment

You personally invest ₦500,000 into the business.

Manual Journal Entry:

  • Date: Today's date
  • Description: "Owner capital investment"
  • Line 1: Bank Account (Asset) – Debit ₦500,000
  • Line 2: Owner's Capital (Equity) – Credit ₦500,000

Result: Your bank balance goes up by ₦500,000, and your equity goes up by ₦500,000.

Why Journal Entries Are Your "Single Source of Truth"

Here's the key insight: All financial data in Keepfig comes from journal entries.

This means: As long as journal entries are correct, your entire financial picture is accurate. Keepfig's automatic journal entry creation ensures consistency across all reports.

💡 Pro Tip: Trust the System

When you record payments, expenses, or invoices through Keepfig's standard workflows, the system creates perfect journal entries every time. You get all the benefits of double-entry accounting without needing to understand the mechanics.

Your job: Focus on running your business. Let Keepfig handle the accounting.

📚 Related Topics

Managing Payments

What Are Payments?

Payments represent money flowing in or out of your business. They can be:

Recording Your First Payment

1 Navigate to Payments
Click "Payments" in the left sidebar of your dashboard.
2 Click "New Payment"
You'll see a form with the following fields:
  • Amount – How much money (e.g., 500.00)
  • Currency – Defaults to your workspace currency (NGN, USD, etc.)
  • Payment Type – Select "Received" for income or "Sent" for expenses
  • Payment Date – When the transaction occurred
  • Contact Name – Who paid you or who you paid (optional but recommended)
  • Description – Brief note about the payment
  • Reference – Transaction ID, invoice number, or external reference
3 Fill in the details
Example: Amount = 5000, Currency = NGN, Type = Received, Contact = "Acme Corp", Description = "Website design project"
4 Click "Save"
Keepfig will:
  • Create the payment record
  • Generate a journal entry (debit Cash, credit Revenue)
  • Update your dashboard widgets (cash balance, revenue, etc.)
  • Add the payment to recent transactions

💡 Pro Tip: Use References Wisely

Always fill in the Reference field with your bank transaction ID, payment gateway reference, or invoice number. This makes reconciliation easier and helps prevent duplicate entries.

Viewing and Filtering Payments

The Payments page shows all your transactions. You can:

📚 Related Topics

Importing Data

Why Import Data?

Instead of manually entering hundreds of transactions, you can import them from:

Importing Step by Step

1 Go to Data Imports
Click "Data Imports" in the sidebar, then "New Import"
2 Choose Your Provider
Select from the dropdown:
  • Paystack – If importing Paystack transaction export
  • Stripe – For Stripe balance history CSV
  • Flutterwave, Square, Generic – Other payment providers
3 Upload Your File
Drag and drop your CSV or Excel file. Supported formats:
  • .csv (comma-separated values)
  • .xlsx (Excel 2007+)
  • .xls (Excel 97-2003)
4 Map Your Columns
Keepfig will analyze your file and suggest column mappings:
Your CSV Column Maps To Required?
Amount / Total Amount ✅ Required
Date / Transaction Date Payment Date ✅ Required
Reference / ID Reference Recommended
Description / Narration Description Optional
Customer / Merchant Contact Name Optional
5 Review and Confirm
You'll see a preview of how your data will be imported. Check:
  • Amounts are correct (watch for currency conversions)
  • Dates are properly formatted
  • Payment types are assigned correctly (received vs sent)
6 Execute Import
Click "Import" to process. Keepfig will:
  • Create payment records for each row
  • Generate journal entries automatically
  • Link to your integration (if applicable)
  • Process in the background (you can close your browser)
  • Check for duplicate files automatically

🔄 Background Processing

Imports now run in the background using an async queue system. This means:

  • Close your browser – Import continues on the server
  • Track progress – Real-time progress bar shows rows processed
  • Auto-retry – If import fails, it retries automatically (3 attempts)
  • Crash recovery – Server restarts won't lose your import

The system polls for updates every 3 seconds until your import completes.

⚠️ Duplicate File Detection

Keepfig automatically detects if you're uploading the same file twice:

  • Smart matching – Compares file content + data type + template + integration
  • Active imports – Won't let you import while same file is being processed
  • Completed imports – Allows re-import with different settings if needed

If duplicate detected: You'll see a dialog with options to continue the existing import or create a new one with "force upload".

✅ What Happens if Import is Interrupted?

Don't worry! The system includes robust crash recovery:

  1. Browser closed – Import continues in background
  2. Server crashes – Import automatically resumes on restart
  3. Duplicate re-upload – System prevents double-processing

Your import session is saved in the database, and the queue system ensures it completes successfully.

Using Templates for Faster Imports

If you regularly import from the same source (e.g., monthly bank statements), save your column mappings as a template:

  1. After mapping columns, click "Save as Template"
  2. Give it a name like "Chase Bank Monthly Statement"
  3. Next time, select the template and skip the mapping step

✅ Pre-Built Templates Available

Keepfig includes ready-to-use templates for popular services:

  • Stripe Balance History – For Stripe transaction exports
  • Paystack Transaction Export – For Paystack CSV downloads

Just select the template and upload your file—no mapping needed!

Workflow Automation

What Are Workflows?

Workflows are visual automation engines that eliminate repetitive manual work. Instead of spending hours each week manually importing transactions, categorizing payments, sending reports, and updating records, you build workflows once and let them run automatically forever.

Real Impact: A typical accounting team spends 10-15 hours per week on repetitive data entry. Workflows reduce this to under 1 hour by automating:

Workflow Architecture

Every workflow follows this structure:

┌─────────────────────────────────────────────────────────┐
│  WORKFLOW EXECUTION FLOW                           │
└─────────────────────────────────────────────────────────┘

    🎯 TRIGGER (What starts the workflow)
    │
    ├─ Paystack: Scheduled Sync
    ├─ Paystack: After Sync Complete
    ├─ Paystack: After Sync Failed  
    ├─ Fraud Detected
    ├─ Stripe Payment Received
    └─ ...and more
    │
    ▼
    🔀 LOGIC NODES (Control how data flows)
    │
    ├─ Loop (For Each) → Process arrays/lists
    │   Example: Loop through 50 transactions
    │
    ├─ Condition (If/Then) → Branch based on rules
    │   Example: If amount > 10000 then notify, else proceed
    │
    └─ Transform Data → Modify/format data
        Example: Convert "USD" to "US Dollars"
    │
    ▼
    ⚡ ACTIONS (What actually happens)
    │
    ├─ Create Payment Record
    ├─ Create Contact
    ├─ Create Journal Entry
    ├─ Send Email
    ├─ Link External Transaction
    ├─ Update Payment Status
    ├─ Match Invoice to Payment
    ├─ Categorize Expense
    └─ ...and more
    │
    ▼
    ✅ RESULT
    └─ Data saved, emails sent, records updated

💡 Data Flows Between Nodes

When nodes are connected, data automatically flows from one to the next. For example:

  • Trigger outputs: paystack_transactions.transactions (array of 50 transactions)
  • Loop receives: Full array, processes one transaction at a time, outputs {{item.amount}}, {{item.reference}}
  • Action receives: Individual transaction data, creates payment record using {{item.amount}}

Key Concepts

🎯 Triggers (What Starts the Workflow)

Triggers are events that automatically start your workflow. Each workflow must have exactly one trigger. Keepfig provides dozens of triggers across different categories:

Payment Integration Triggers:

System Event Triggers:

⚠️ Important: One Trigger Per Workflow

Each workflow can only have one trigger. If you need multiple triggers, create separate workflows. This keeps workflows focused and easier to debug. Example: Create one workflow for "Paystack Daily Sync" and another for "Stripe Hourly Sync" rather than trying to combine them.

⚡ Actions (What Happens Next)

Actions are the steps that execute after a trigger fires. Unlike triggers, you can chain unlimited actions together to build complex automation. Actions are organized into categories:

Data Creation Actions:

Data Modification Actions:

Communication Actions:

Reporting Actions:

Note: This is not an exhaustive list. Browse the workflow builder sidebar to see all available actions. New actions are added regularly as Keepfig expands integrations.

🔀 Logic Nodes (Control Flow)

Logic nodes control how your workflow executes:

🔧 Configuring Nodes

Each node has configuration options that appear when you click on it:

Common Automation Use Cases

💸 Automatic Payment Import

Trigger: Paystack: Scheduled Sync (daily)
Actions: Loop through transactions → Create Payment → Link External Transaction

📧 Large Payment Alerts

Trigger: Paystack: New Payment Detected
Actions: Condition (if amount > 50000) → Send Email to finance team

📊 Daily Sync Reports

Trigger: Paystack: After Sync Complete
Actions: Generate Report → Update Dashboard → Send Email summary

🚨 Fraud Detection Alerts

Trigger: Fraud Detected
Actions: Send Email alert → Update payment status → Create audit log

Creating Your First Workflow

1 Navigate to Workflows
Click "Workflows" in the sidebar, then "Create Workflow" or choose a template from the marketplace
2 Add a Trigger Node
From the left sidebar, expand "Triggers" and drag a trigger node onto the canvas. Example: "Paystack: Scheduled Sync"
  • Click the node to configure it
  • Select your Paystack integration
  • Set polling interval (e.g., "Daily")
  • Choose transaction filter (e.g., "Success Only")
3 Add Action Nodes
Drag action nodes from the left sidebar onto the canvas:
  • Loop node: Set array source to "paystack_transactions.transactions" (from trigger)
  • Create Payment: Map fields using {{item.amount}}, {{item.reference}}, etc.
  • Send Email: Use {{synced_count}} transactions synced in subject line
4 Connect the Nodes
Draw lines between nodes by clicking and dragging from one node's output handle to another node's input handle. This shows the flow of data.
  • Trigger → Loop (all transactions flow to loop)
  • Loop → Create Payment (each transaction creates a payment)
  • Loop → Send Email (summary sent after all payments created)
5 Configure Variables
Click each node and set configuration. Use {{variable}} syntax for dynamic data: 
Email subject: "{{synced_count}} new Paystack payments synced"
Payment amount: {{item.amount}}
Payment reference: {{item.reference}}
Contact name: {{item.customer.email}}
6 Test and Enable
Click "Test Run" to execute the workflow once and verify it works. Check execution logs for errors. When ready, click "Enable" to activate automatic execution.

Complete Workflow Example: Automated Paystack Sync

💡 Real-World Scenario

Problem: Your business processes 200+ Paystack transactions daily. Your bookkeeper spends 3 hours every morning manually importing them, creating payment records, categorizing transactions, and sending daily reports to the CFO.

Solution: One workflow that runs automatically every morning at 6 AM:

TRIGGER
└─ Paystack: Scheduled Sync
   - Polling interval: Daily at 6:00 AM
   - Transaction filter: Success only
   - Integration: Main Paystack Account
   
NODE 1: LOOP
└─ Loop (For Each Transaction)
   - Array source: paystack_transactions.transactions
   - Item variable: {{item}}
   - Parallel processing: Enabled (batch size: 10)
   
NODE 2: CONDITION (Inside Loop)
└─ If amount > 50000
   - Then: Branch A (Large Payment Alert)
   - Else: Branch B (Normal Processing)
   
BRANCH A: Large Payment Alert
├─ Send Email
│  - To: cfo@company.com
│  - Subject: "Large payment received: {{item.amount}} NGN"
│  - Body: "Customer: {{item.customer.email}}, Ref: {{item.reference}}"
└─ Create Payment (with high-value flag)
   
BRANCH B: Normal Processing
└─ Create Payment
   - Amount: {{item.amount}}
   - Currency: {{item.currency}}
   - Reference: {{item.reference}}
   - Contact: {{item.customer.email}}
   - Payment method: bank_transfer
   - Payment type: received
   
NODE 3: LINK EXTERNAL (After Loop)
└─ Link External Transaction
   - Links payments to Paystack API
   - Prevents duplicates on next sync
   
NODE 4: SEND DAILY REPORT
└─ Send Email
   - To: finance@company.com
   - Subject: "Daily Paystack sync: {{synced_count}} transactions"
   - Body: "Processed {{synced_count}} payments totaling {{total_amount}} NGN"
   - Attachment: CSV report

Result:

  • ✅ 200+ transactions imported automatically every morning
  • ✅ Large payments (>50K) trigger instant CFO alerts
  • ✅ All payments linked to Paystack to prevent duplicates
  • ✅ Daily summary email with CSV report sent to finance team
  • ✅ Time saved: 3 hours/day → 5 minutes/day (just reviewing the summary)
  • ✅ Cost savings: $450/month in bookkeeper time

Why Workflows Matter for Small Businesses

Traditional accounting software forces you to manually enter every transaction. Keepfig's workflow automation means:

Bottom line: Workflows turn Keepfig from "accounting software" into "your automated accounting department."

Connecting Integrations

Why Connect Integrations?

Integrations let Keepfig automatically fetch transactions from your payment processors, banks, and other financial tools. This eliminates manual data entry and keeps your records up to date.

Available Integrations

Connecting Paystack (Example)

1 Go to Integrations
Click "Integrations" in the sidebar
2 Select Paystack
Click "Connect" next to the Paystack logo
3 Enter Your API Keys
You'll need:
  • Secret Key – From your Paystack dashboard (Settings → API Keys & Webhooks)
  • Public Key – Also from Paystack settings
4 Test Connection
Keepfig will verify your keys by making a test API call
5 Enable Sync
Choose sync options:
  • Auto-sync – Automatically import new transactions daily
  • Historical sync – Import past transactions (last 90 days)

✅ Integration Connected!

Once connected, you can:

  • Manually sync anytime by clicking "Sync Now"
  • View sync history and status
  • Create workflows that trigger on new transactions
  • Import data using the integration in Data Imports

Fraud Detection

What Is Fraud Detection?

Keepfig includes built-in fraud detection to verify invoices and receipts. Upload a document and get instant analysis including:

Checking a Document

1 Go to Fraud Detection
Click "Fraud Detection" in the sidebar
2 Upload a Document
Drag and drop or click to select:
  • PDF invoices or receipts
  • JPG/PNG images of receipts
  • Scanned documents
3 Review Results
You'll see a detailed report:
Check What It Means
✅ ACCEPT Document looks legitimate, safe to process
⚠️ REVIEW Some suspicious indicators, manual review recommended
❌ REJECT High fraud risk, likely fake or manipulated

⚠️ Privacy & GDPR Compliance

Keepfig never stores your original documents. We only save cryptographic hashes for duplicate detection. All forensic analysis happens in memory and results are stored separately from your document images.

Understanding Fraud Signals

The fraud report includes specific signals that contributed to the decision:

Custom Dashboards

Why We Encourage Custom Dashboards

Unlike traditional accounting software that forces everyone to use the same generic dashboard, Keepfig believes your dashboard should reflect your business priorities.

Every business tracks different metrics:

With custom dashboards, you can:

✅ Real Benefits Our Users See

  • Founders: "I check my runway every morning in 5 seconds instead of opening Excel"
  • Operations: "Our expense tracking dashboard catches overspending before it becomes a problem"
  • Sales: "The top customers widget helps us prioritize relationship management"

Creating a Dashboard

1 Open Dashboard Manager
Click "Dashboards" in the sidebar, then the "+" icon
2 Name Your Dashboard
Be specific about its purpose:
Examples: "Founder Metrics", "Q1 Investor Report", "Expense Analysis", "Sales Performance"
3 Add Widgets
Click "Add Widget" and choose from:
  • Metric Widgets (single numbers): Cash Balance, Revenue, Burn Rate, Runway
  • Chart Widgets (visual trends): Line charts, bar charts, pie charts, donut charts
  • List Widgets (recent activity): Latest transactions, new customers, pending invoices
  • Table Widgets (detailed data): Expense reports, invoice aging, payment history
  • Cap Table Widget (equity tracking): Ownership breakdown, dilution analysis
4 Configure Each Widget
Click the gear icon on any widget to customize:
  • Data source: What metric or data to display
  • Chart type: Line, bar, pie, or donut (you can change this anytime)
  • Timeframe: This month, last 30 days, last 90 days, this year, all time
  • Filters: Show only certain categories, contacts, or payment types
  • Limit: How many items to show (e.g., top 10 customers)
5 Arrange Your Layout
Drag widgets to reorder them. Resize by dragging corners. Put your most important metrics at the top where you'll see them first.
6 Save and Set as Default
Click "Save". Toggle "Set as Default" to make this dashboard load when you sign in.

Example Dashboard Configurations

Example 1: Founder Dashboard (Startup Metrics)

Purpose: Monitor business health and runway for investor updates

Widget Type Data Source Configuration Why It Matters
Metric Cash Balance Current balance Know your available liquidity
Metric Burn Rate Monthly average, last 3 months Track spending velocity
Metric Runway Months remaining Plan fundraising timeline
Metric Monthly Revenue This month vs last month Monitor growth trajectory
Line Chart Revenue Trend Last 12 months Visualize growth for investors
Line Chart Expense Trend Last 12 months Identify spending patterns
Pie Chart Cap Table Current ownership Track dilution at a glance
List Top Customers By revenue, top 5 Focus on key relationships

Example 2: Operations Dashboard (Expense Control)

Purpose: Monitor spending and catch budget overruns early

Widget Type Data Source Configuration Why It Matters
Metric Total Expenses This month Quick spend check
Metric Average Daily Spend Last 30 days Identify unusual spending days
Bar Chart Expenses by Category This month See where money is going
Line Chart Monthly Expenses Last 6 months Spot trends and seasonality
Table Recent Expenses Last 20 transactions Quick review of recent spending
List Top Vendors By spend, top 10 Identify negotiation opportunities

Example 3: Sales Dashboard (Revenue Tracking)

Purpose: Monitor sales performance and customer health

Widget Type Data Source Configuration Why It Matters
Metric Monthly Revenue This month Track toward quota
Metric Revenue Growth Month-over-month % Measure acceleration
Metric Average Deal Size Last 30 days Monitor deal quality
Line Chart Revenue Trend Last 12 months Show seasonal patterns
Bar Chart Revenue by Customer This quarter, top 10 Identify concentration risk
Pie Chart Revenue by Product This year Understand product mix
List Recent Payments Last 10 received Verify customer payments

💡 Pro Tips for Effective Dashboards

  • Start simple: Begin with 4-6 widgets, add more as needed
  • Group related metrics: Put revenue widgets together, expense widgets together
  • Use color wisely: Green for positive metrics, red for alerts/warnings
  • Update timeframes regularly: Switch from "last 30 days" to "this quarter" as your business matures
  • Create multiple dashboards: Daily operations dashboard + monthly review dashboard
  • Share with your team: Export dashboard screenshots for board meetings or investor updates

Cap Table & Equity Management NEW

What Is a Cap Table?

A cap table (capitalization table) tracks who owns what percentage of your company. It shows:

Why it matters: Your cap table determines control (voting rights), economics (who gets paid when), and fundraising (how much dilution each round causes). Keeping it accurate is critical for taxes, fundraising, and exits.

⚠️ Common Cap Table Mistakes We Help You Avoid

  • Not tracking vesting schedules properly (can cause disputes on departure)
  • Forgetting to account for options when calculating dilution
  • Missing 83(b) election deadlines for early exercised options
  • Not documenting capital contributions from founders

Key Concepts Explained

Share Classes

Different types of shares with different rights:

Vesting

Vesting means earning your shares over time instead of getting them all at once. Standard vesting terms:

Example: You're granted 40,000 options with standard 4-year vesting and 1-year cliff:

Fully Diluted Ownership

Fully diluted means counting all shares as if every option and warrant had been exercised. This is the most conservative (and honest) way to calculate ownership.

Formula: Your shares / (Total issued shares + All unvested options + All warrants)

Managing Shareholders

1 Go to Cap Table → Shareholders
Click "Cap Table" in the sidebar, then "Shareholders"
2 Add a New Shareholder
Click "Add Shareholder" and fill in:
  • Name: Full legal name
  • Email: Contact email (required for equity grant notices)
  • Shareholder Type: Founder, Employee, Investor, Advisor, or Other
  • Tax ID: National ID, TIN, or SSN (for tax reporting)
  • Address: Legal address (required for stock certificates)
3 View Shareholder Details
Click the eye icon (👁️) next to any shareholder to see:
  • Total shares owned across all share classes
  • Ownership percentage (fully diluted)
  • Capital contributions made
  • Equity grants received (with vesting status)

Recording Capital Contributions

When shareholders (especially founders) inject cash into the company, you need to record it properly for accounting and tax purposes. There are two ways to do this in Keepfig:

Method 1: From Shareholder Detail Page (Recommended for Equity Transactions)

Use when: Shareholder is contributing cash in exchange for shares

1 Navigate to Shareholder Details
Go to Cap Table → Shareholders, click the eye icon (👁️) on the shareholder
2 Click "Record Contribution"
Fill in the form:
  • Amount: Cash contributed (e.g., ₦500,000)
  • Date: When the contribution was made
  • Payment Method: Bank Transfer, Cash, Wire, etc.
  • Reference: Bank transaction ID or check number
  • Notes: Optional description (e.g., "Series A closing")
3 Issue Shares (Optional)
Toggle "Issue Shares" if you're exchanging the contribution for equity:
  • Share Class: Select Common, Preferred, or Warrant
  • Number of Shares: How many shares to issue
  • Vesting: Typically "No Vesting" for direct stock grants
4 Submit
Keepfig automatically:
  • Creates a payment record (category: Capital Contribution)
  • Creates a journal entry (Debit: Cash, Credit: Owner's Equity)
  • Creates an equity grant (if shares issued)
  • Links everything together for audit trail

Method 2: Through Payment Form (Flexible for All Contributions)

Use when: Recording any capital contribution, with or without immediate share issuance

1 Go to Payments → Create Payment
Click "Payments" in sidebar, then "Create Payment"
2 Select Payment Type: Received
Then select category: Capital Contribution
3 Shareholder Selector Appears
Choose the contributing shareholder from the dropdown. The contact name will auto-fill.
4 Select Account
The account selector automatically filters to show only equity accounts (Owner's Equity, Retained Earnings, etc.)
If you don't have an equity account yet, create one from Chart of Accounts.
5 Fill Remaining Fields
Amount, date, payment method, reference. Then submit.

💡 Which Method Should I Use?

  • Use Method 1 (Shareholder page) when you want to issue shares immediately in exchange for the contribution
  • Use Method 2 (Payment form) when recording contributions without immediate share issuance, or when you prefer the flexibility of the payment workflow
  • Both create identical accounting entries (DR: Cash, CR: Owner's Equity)
  • Both appear in contribution history on the shareholder detail page

Issuing Equity Grants

1 Go to Cap Table → Equity Grants
Click "Create Grant"
2 Select Grant Type
  • Direct Stock: Immediate ownership, no vesting required (for founders or investors)
  • Stock Options: Must vest before exercise (for employees)
  • Warrants: Right to purchase shares, often for investors or advisors
3 Fill in Grant Details
Field Description Example
Shareholder Who receives the grant Jane Doe
Share Class Type of shares Common Stock
Number of Shares How many shares 50,000
Strike Price Price per share (for options/warrants) ₦1.00
Grant Date When grant is issued 2025-01-01
Vesting Schedule How shares vest over time 4-year, 1-year cliff
4 Configure Vesting (if applicable)
For stock options:
  • Vesting Period: Total time to fully vest (e.g., 4 years)
  • Cliff Period: Time before first vesting (e.g., 1 year)
  • Vesting Frequency: How often shares vest (monthly, quarterly, annually)
For direct stock, select "No Vesting" to grant shares immediately.
5 Submit Grant
Keepfig automatically:
  • Creates the equity grant record
  • Updates cap table ownership percentages
  • Starts vesting clock (for options)
  • Generates stock certificate (for direct grants)

Understanding Your Dashboard Widget

The Cap Table widget provides a visual snapshot of ownership. You can:

✅ Real-World Scenario: Founder Capital Injection

Situation: Co-founder Sarah contributes ₦2,000,000 cash to fund operations. Company issues 20,000 common shares in exchange.

Step-by-step:

  1. Go to Cap Table → Shareholders → Click eye icon on Sarah
  2. Click "Record Contribution"
  3. Amount: ₦2,000,000, Date: Today, Method: Bank Transfer
  4. Toggle "Issue Shares" ON
  5. Share Class: Common Stock, Shares: 20,000, Vesting: No Vesting
  6. Submit

What Keepfig does automatically:

  • Payment record created (₦2,000,000 received from Sarah)
  • Journal entry: DR Cash ₦2,000,000 / CR Owner's Equity ₦2,000,000
  • Equity grant created: 20,000 shares issued to Sarah
  • Cap table updated: Sarah now owns 20,000 shares
  • Dashboard widget shows Sarah's ownership percentage

Result: Complete audit trail from cash receipt to equity issuance, fully compliant for tax and legal purposes.

Common Cap Table Tasks

Adding a New Investor

  1. Create shareholder record (type: Investor)
  2. Record capital contribution (investment amount)
  3. Issue equity grant (preferred stock, usually)
  4. Configure liquidation preference and conversion terms (in share class settings)

Granting Employee Options

  1. Create shareholder record (type: Employee)
  2. Issue equity grant (stock options)
  3. Set vesting schedule (standard: 4 years, 1-year cliff)
  4. Set strike price (typically 409A valuation)
  5. Employee receives grant notice email

Handling Employee Departure

  1. Go to Equity Grants, find employee's grants
  2. Calculate vested shares (based on tenure)
  3. Mark unvested shares as "Cancelled"
  4. If employee exercises vested options: Record exercise transaction, issue shares
  5. If employee doesn't exercise: Options expire per grant terms

Preparing for Fundraising

  1. Run cap table report (fully diluted ownership)
  2. Export equity grant history (all grants with dates, vesting, strike prices)
  3. Generate shareholder list with contact info
  4. Review option pool sufficiency (do you need to increase pool?)
  5. Share reports with investors during diligence

⚠️ Important Tax and Legal Notes

  • 83(b) Elections: Employees exercising options early should file 83(b) within 30 days (consult tax advisor)
  • 409A Valuations: Strike prices for options must be at or above fair market value per IRS rules
  • Securities Laws: Equity issuances may be subject to securities regulations, consult legal counsel
  • Stock Certificates: Issue physical or electronic certificates for all direct stock grants

Best Practices

Organizing Your Data

Use Consistent Contact Names

Always use the same name format for contacts. Instead of mixing "Acme Corp", "Acme", and "Acme Corporation", pick one and stick with it. This ensures accurate reporting and makes filtering easier.

Fill in References

The reference field is your friend! Always include:

This prevents duplicates and makes reconciliation much easier.

Categorize Expenses

Create expense categories that match your business needs. Common categories:

Security Tips

Protect Your API Keys

Never share your integration API keys. Treat them like passwords. If you suspect a key has been compromised, regenerate it immediately in your payment processor's dashboard.

Review Fraud Alerts

If a document is flagged for review, always investigate before processing. Look for:

Enable Two-Factor Authentication

Add an extra layer of security to your Keepfig account by enabling 2FA in your account settings.

Financial Reporting

Reconcile Regularly

Match your Keepfig records with bank statements at least monthly. This catches errors early and ensures accuracy.

Monitor Key Metrics

Create a dashboard with your most important metrics and check it daily or weekly:

Export for Your Accountant

Keepfig's journal entries follow standard accounting principles. Export them as CSV and share with your accountant for tax filing or financial audits.

Need more help? Check out our Technical Documentation or contact support.