Maybe

Maybe is an open-source personal finance application built for individuals and households who want complete control over their financial data without relying on third-party cloud services. Built on Ruby on Rails with Hotwire and PostgreSQL, it tracks net worth, income, expenses, budgets, investments, and multi-currency accounts through a clean, minimal UI designed to remove complexity rather than add it.

The app follows a hybrid event-sourced architecture where financial facts — transactions, trades, and valuations — are stored as immutable Entry records and asynchronously materialized into balance and holding cache tables via Sidekiq background jobs. This design keeps every view consistent while maintaining fast page loads. Plaid integration enables automated bank syncing, and an optional OpenAI-powered AI assistant can answer questions about your finances with full context of your accounts.

Maybe supports multi-currency tracking, CSV imports for transactions and trades, household member invitations, two-factor authentication, and a REST API with key management for custom automations. The Docker-based deployment lets anyone run the full stack — Rails, PostgreSQL, and Redis — in minutes. The codebase is released under AGPLv3 and the company made a final v0.6.0 release in July 2025 before pivoting, leaving the software fully functional and available for forking.

With over 54,000 GitHub stars and contributions from hundreds of developers, Maybe represents one of the most polished self-hosted personal finance codebases available. Its emphasis on intentional simplicity — asking “what can we delete?” rather than what to add — and its Rails-native component architecture make it an excellent foundation for developers looking to extend or fork a production-quality finance application.

What You Get

• Net worth dashboard - Visualizes your total net worth trend over time with a balance sheet breakdown of all assets and liabilities across every connected account.
• Transaction management - Rich transaction filtering, searching, bulk editing, categorization rules, merchant detection, tag support, and automatic transfer detection that excludes double-counted entries from budgets.
• Budget tracking - Monthly budget views with category averages, income summaries, and spending breakdowns, with subcategory support and one-time expense exclusions for accurate averages.
• Investment portfolio - Tracks holdings, trades, and balance trends for investment accounts with multi-currency support and optional market data via the Synth provider.
• AI financial assistant - Optional OpenAI-powered chat that has full read access to your financial data and can answer questions, summarize spending, and surface patterns through a streaming Turbo Streams interface.
• CSV import and REST API - Import transactions, accounts, and trades via flexible CSV templates, and build custom automations using the REST API with managed API keys.
• Multi-user household - Invite household members to share a single Maybe instance, with admin controls and 2FA support for account security.
• Docker self-hosting - Deploy the complete stack with Docker Compose in under ten minutes, with a single-container option and documented upgrade paths between versions.

Common Use Cases

• Privacy-first budgeting - Individuals who want Mint-like budgeting without sharing financial data with any third party run Maybe on a home server or VPS with full local data ownership.
• Developer learning platform - Rails developers use Maybe’s codebase to study production-grade patterns: delegated types, Hotwire with ViewComponent, hybrid event-sourcing, and Sidekiq job orchestration.
• Household finance tracking - Families managing combined finances use Maybe’s multi-user household feature to track shared accounts, split budgets, and monitor joint net worth over time.
• Fork baseline for fintech products - Indie developers and startups fork Maybe as a production-quality starting point for custom personal finance tools, extending it with proprietary bank integrations or reporting features under AGPLv3.
• Investment portfolio monitoring - Users with brokerage and retirement accounts track holdings, trades, and performance trends alongside cash accounts in a unified net worth view.

Under The Hood

Architecture Maybe is structured as a layered Rails monolith with a domain model organized around delegated types — the Entry abstraction unifies transactions, valuations, and trades under a single polymorphic record, while Account uses delegated types to express depository, investment, loan, credit card, and crypto accounts without inheritance bloat. Cross-cutting behaviors are composed through Ruby modules and concerns (Syncable, Monetizable, Chartable, Enrichable), keeping each concern narrow and reusable. A state machine via AASM on accounts enforces explicit lifecycle transitions. The most architecturally distinctive decision is a hybrid event-sourced approach: financial facts are written as immutable entries, then background Sidekiq jobs materialize them into cache tables (balances, holdings) for fast querying. This solves the fundamental tension in personal finance between data accuracy and page performance, at the cost of eventual consistency that the team acknowledged as their primary remaining technical challenge.

Tech Stack The backend runs Ruby 3.4.4 on Rails 7.2.2 with PostgreSQL for persistence and Redis for Sidekiq job queuing and ActionCable. The frontend uses the full Hotwire stack — Turbo for page navigation and streaming updates, Stimulus for lightweight JavaScript controllers, and ViewComponent with a custom design system (DS::* components) for testable, reusable UI elements. Asset delivery uses Propshaft with Tailwind CSS v4 and importmaps for zero-build JavaScript modules. Sidekiq with Sidekiq-Cron handles background processing. External integrations include Plaid for automated bank syncing, a custom Synth provider for market data and security prices, OpenAI for the AI assistant, Stripe for optional subscription management, and AWS S3 for Active Storage. Observability is covered by Sentry, Rack::MiniProfiler, Vernier, Logtail, and Skylight.

Code Quality The test suite spans extensive model tests, controller tests, system tests using Capybara, service interface tests, and data migration tests — over 195 test files in total with fixture-based setups and expressive assertion styles. Error handling is explicit: sync jobs use tagged structured logging, controllers rescue specific exception types, and the Faraday HTTP client layer uses retry middleware with concrete retry logic per provider. Code style is enforced by RuboCop with rails-omakase and Biome for JavaScript. The codebase shows consistent naming, well-scoped concerns, and strong parameters throughout. Some service objects grow large as they absorb domain complexity, but the overall discipline is high for an open-source project of this scale and contributor count.

What Makes It Unique The most technically interesting aspect of Maybe is its streaming AI integration: OpenAI responses are streamed token-by-token into the Rails-rendered UI via Turbo Streams and ActionCable, with thinking indicators and incremental message rendering — delivering a conversational AI UX without a React frontend. The hybrid event-sourcing model for financial data is a genuinely thoughtful solution to the accuracy-vs-performance tradeoff that breaks most personal finance apps. The design system built with ViewComponent enforces strict component boundaries within a traditional server-rendered Rails application, making the UI as maintainable as a component-based frontend without the JavaScript build complexity. Transfer detection as a first-class feature — auto-detecting transfers between accounts and excluding them from budgets without requiring user categorization — solves a problem that most competing apps handle awkwardly.

Self-Hosting

Maybe is released under the GNU Affero General Public License version 3 (AGPLv3). This is a strong copyleft license that allows you to use, modify, and self-host the software freely, including for commercial internal use. The critical implication of AGPLv3 is the network copyleft clause: if you modify Maybe and make it available to users over a network — even without distributing the binary — you must release your modifications under AGPLv3 as well. For individuals and organizations running an unmodified or minimally modified instance for personal or internal use, this creates no practical obligation. For developers who intend to fork Maybe into a hosted SaaS product, AGPLv3 requires open-sourcing the fork. “Maybe” is also a registered trademark of Maybe Finance Inc., so forks must avoid using the name or logo.

Running Maybe yourself requires a server with Docker Compose support, a minimum of 1GB RAM (more comfortable at 2GB+), and outbound internet access if you want bank syncing via Plaid or market data via the Synth provider. The standard deployment runs three containers — the Rails application, PostgreSQL, and Redis — behind a reverse proxy. Upgrades between versions follow documented migration guides; the team made breaking changes in v0.5.0 (switching to Redis/Sidekiq) that required manual intervention. As a self-hoster, you are responsible for backups, PostgreSQL maintenance, uptime monitoring, and applying security patches. The codebase received its final official release in July 2025 and is no longer actively maintained by Maybe Finance Inc., which means no further bug fixes, security patches, or dependency updates will come from upstream.

The practical trade-off versus a managed personal finance service is significant now that Maybe is officially unmaintained. There is no support tier, no SLA, no automated security updates, and no guarantee that Plaid or Synth integrations will continue working as those providers evolve their APIs. What you gain is complete data sovereignty, no subscription fees, and a production-quality codebase with 54,000+ stars and hundreds of contributors that you can fork and maintain. Developers willing to take on maintenance responsibility will find Maybe an unusually solid foundation — far more mature than typical side-project open-source tools — but should plan for the operational burden of running a Rails application on PostgreSQL and Redis long-term.