Use Cases

Crane Ledger's flexible, API-first architecture makes it perfect for a wide range of accounting and financial applications. Whether you're building client software, managing complex business structures, or modernizing your small business operations, Crane Ledger provides the foundation you need.

🏢 Accounting Firm Software Platform

The Challenge

Accounting firms build custom software for their clients but struggle with:

  • Client data isolation - Each client needs separate, secure financial data
  • Scalability - Managing hundreds of client organizations
  • Billing complexity - Separate billing per client while maintaining firm oversight
  • Consolidated reporting - Firm-wide financial analysis across all clients
  • Integration requirements - Connecting to banks, payroll systems, tax software

Crane Ledger Solution

Accounting Firm Platform
├── Firm Master Organization (Billing oversight)
│   ├── Client A (Linked - isolated data)
│   ├── Client B (Linked - isolated data)
│   └── Client C (Linked - isolated data)

Implementation

Client Onboarding:

// Create isolated client organization
const clientOrg = await createSubOrganization({
  parent_organization_id: firmMasterOrg.id,
  organization_name: client.name,
  relationship_type: 'linked',        // Data isolation
  billing_type: 'shared',             // Firm manages billing
  base_currency_code: client.currency
});

// Create client-specific API key
const apiKey = await createApiKey({
  organization_id: clientOrg.id,
  name: `Client Portal - ${client.name}`,
  permissions: ['read', 'write']
});

Multi-Client Dashboard:

// Get all client organizations
const clients = await listOrganizations({
  parent_id: firmMasterOrg.id,
  relationship_type: 'linked'
});

// Aggregate financial metrics
const firmOverview = await Promise.all(
  clients.map(client =>
    getOrganizationFinancials(client.id)
  )
);

Benefits

✅ Perfect client isolation - Each client's data completely separate ✅ Centralized billing - Firm manages all API costs with per-client usage tracking ✅ Scalable architecture - Handle hundreds of clients on single infrastructure ✅ Firm oversight - Monitor usage and financial health across all clients ✅ White-label ready - Build client portals with isolated data access

Real-World Example

TaxPrep Pro - Accounting firm serving 500+ small businesses:

  • Client organizations: 500+ isolated orgs
  • API calls: 50,000/month across all clients
  • Billing: Each client pays $49/month, firm pays $0.01 per API call
  • Result: $24,500/month revenue, $500/month API costs, 95% margin

🏗️ Real Estate Investment Company

The Challenge

Real estate investment companies manage complex structures:

  • Multiple entities - LLCs, partnerships, trusts per property
  • Consolidated reporting - Roll up financials for investors and tax purposes
  • Property-level tracking - Separate books per property or portfolio
  • Investor reporting - Individual statements for limited partners
  • Depreciation schedules - Complex tax depreciation across assets
  • Cash flow management - Track distributions and capital calls

Crane Ledger Solution

Real Estate Holding Company
├── Master Organization (Consolidated reporting)
│   ├── Property A LLC (Owned - consolidated financials)
│   │   ├── Operating Account
│   │   └── Reserve Account
│   ├── Property B LLC (Owned - consolidated financials)
│   ├── Management Company (Owned - consolidated operations)
│   └── Investor Partnership (Owned - consolidated distributions)

Implementation

Property-Level Organization Setup:

// Create property-specific organization
const propertyOrg = await createSubOrganization({
  parent_organization_id: holdingCompany.id,
  organization_name: `${property.name} LLC`,
  relationship_type: 'owned',         // Consolidated reporting
  billing_type: 'shared',             // Holding company pays
  base_currency_code: 'USD'
});

// Set up property-specific chart of accounts
const accounts = await createChartOfAccounts(propertyOrg.id, {
  operating_account: '1001',
  reserve_account: '1002',
  depreciation_account: '1601',
  mortgage_payable: '2001'
});

Consolidated Financial Reporting:

// Get consolidated balance sheet
const consolidatedBalance = await getConsolidatedReport({
  parent_organization_id: holdingCompany.id,
  report_type: 'balance_sheet',
  as_of_date: '2024-12-31'
});

// Generate investor statements
const investorStatements = await generateInvestorReports({
  partnership_id: partnershipOrg.id,
  investors: investorList,
  period: 'Q4-2024'
});

Depreciation Tracking:

// Set up depreciation schedules
const depreciationSchedule = await createRecurringTransaction({
  organization_id: propertyOrg.id,
  type: 'depreciation',
  frequency: 'monthly',
  entries: [
    { account_id: depreciationExpense.id, entry_type: 'debit', amount: monthlyDepreciation },
    { account_id: accumulatedDepreciation.id, entry_type: 'credit', amount: monthlyDepreciation }
  ]
});

Benefits

✅ Perfect property isolation - Separate books per property/LLC ✅ Consolidated reporting - Roll up financials for investors and tax authorities ✅ Complex entity structures - Handle partnerships, trusts, multiple LLCs ✅ Investor reporting - Automated statements for limited partners ✅ Tax depreciation - Track and automate depreciation schedules

Real-World Example

Metro Properties - $50M real estate portfolio:

  • Organizations: 25 properties + management company + investor partnerships
  • Monthly transactions: 2,000+ across all entities
  • Reports generated: 50 investor statements quarterly
  • API calls: 15,000/month
  • Result: Replaced 3 full-time accountants, $180K annual savings

👨‍💼 Small Business Owner

The Challenge

Small business owners want to move away from QuickBooks but face:

  • Complex migration - Moving years of financial data
  • Integration requirements - Connect to payment processors, banks, POS systems
  • Cost concerns - Want predictable pricing without enterprise overhead
  • Mobile access - Need financial data anywhere, anytime
  • Tax preparation - Easy access to financial reports for accountants
  • Scalability - Start simple but grow as business expands

Crane Ledger Solution

Small Business Setup
├── Master Organization (Main business)
│   ├── Operating Accounts (Primary banking)
│   ├── Customer Invoices (AR tracking)
│   ├── Vendor Bills (AP tracking)
│   ├── Payroll Integration (Automated entries)
│   └── Tax Categories (Organized for filing)

Implementation

Quick Start Setup:

// Create business organization
const business = await createMasterOrganization({
  organization_name: 'My Small Business',
  user_github_id: user.githubId,
  user_email: user.email,
  base_currency_code: 'USD'
});

// Set up basic chart of accounts
await setupBasicChartOfAccounts(business.id, {
  industry: 'retail',
  tax_method: 'cash'
});

Payment Processor Integration:

// Connect Stripe for payment processing
const stripeIntegration = await setupStripeIntegration({
  organization_id: business.id,
  stripe_account_id: stripeAccount.id,
  auto_reconcile: true
});

// Process incoming payment
webhook.on('payment.succeeded', async (payment) => {
  // Record payment in accounting system
  await recordInvoicePayment({
    invoice_id: payment.metadata.invoice_id,
    amount: payment.amount,
    payment_date: payment.created,
    reference: `Stripe: ${payment.id}`
  });
});

Bank Reconciliation:

// Import bank statement
const reconciliation = await importBankStatement({
  organization_id: business.id,
  account_id: checkingAccount.id,
  statement_file: csvFile,
  auto_match: true
});

// Review and complete reconciliation
const completed = await completeReconciliation(reconciliation.id, {
  matched_transactions: matchedItems,
  adjustments: manualAdjustments
});

Benefits

✅ Simple migration - API-first design makes integration easy ✅ Predictable costs - Credit-based pricing scales with usage ✅ Modern integrations - Connect to Stripe, banks, POS systems ✅ Mobile-ready - Access financial data from anywhere ✅ Tax-ready reports - Generate reports for accountants ✅ Room to grow - Start simple, add complexity as business scales

Real-World Example

Corner Café - Local coffee shop with $500K annual revenue:

  • Migration: Moved from QuickBooks in 2 weeks
  • Integrations: Stripe payments, Square POS, bank feeds
  • Monthly usage: 200 transactions, 50 invoices/bills
  • Cost: $15/month (Builder package)
  • Result: Real-time financial visibility, automated reconciliation

🔧 Integration Patterns

Common Integration Architectures

Client Portal Pattern:

// Multi-tenant client portal
class AccountingPortal {
  constructor(clientId) {
    this.clientId = clientId;
    this.apiKey = this.getClientApiKey(clientId);
  }

  async getFinancialOverview() {
    return await craneLedger.getOrganizationOverview({
      apiKey: this.apiKey
    });
  }

  async createInvoice(invoiceData) {
    return await craneLedger.createInvoice({
      apiKey: this.apiKey,
      ...invoiceData
    });
  }
}

Webhook-Driven Automation:

// Automated transaction processing
app.post('/webhooks/stripe', async (req, res) => {
  const event = req.body;

  switch (event.type) {
    case 'payment_intent.succeeded':
      await recordPayment(event.data.object);
      break;
    case 'invoice.payment_succeeded':
      await updateInvoiceStatus(event.data.object);
      break;
  }

  res.sendStatus(200);
});

Background Processing:

// Recurring transaction automation
const payrollProcessor = new RecurringTransaction({
  organization_id: business.id,
  frequency: 'biweekly',
  template: {
    description: 'Payroll - {period}',
    entries: payrollEntries
  },
  auto_post: true
});

payrollProcessor.scheduleNextRun();

🚀 Getting Started by Use Case

For Accounting Firms

  1. Create firm master organization
  2. Set up client onboarding workflow
  3. Build client portal application
  4. Implement billing automation
  5. Add consolidated firm reporting

For Real Estate Companies

  1. Design organization hierarchy
  2. Set up property-level accounting
  3. Implement consolidated reporting
  4. Create investor statement generation
  5. Automate depreciation tracking

For Small Businesses

  1. Migrate from existing system
  2. Set up bank and payment integrations
  3. Configure basic chart of accounts
  4. Enable mobile access
  5. Set up automated reporting

📊 Success Metrics

Performance Benchmarks

Use CaseOrganizationsMonthly API CallsCost/MonthSavings
Accounting Firm500+50,000$500$200K+
Real Estate Co2515,000$150$180K
Small Business1500$15$50K

Key Success Factors

  • API-first design enables seamless integrations
  • Multi-organization support handles complex business structures
  • Credit-based pricing scales with usage
  • Worker architecture ensures high performance
  • Comprehensive documentation accelerates development

Crane Ledger adapts to your business model, whether you're serving thousands of clients or managing a single location. The flexible API-first architecture supports any accounting workflow you can imagine.

Need help?

Create a free account to access our support portal. Once signed in, use the Support tab in your dashboard to submit a support ticket — our team typically responds within 24 hours.