Canopy

Inspiration

Most banking apps are good at showing how much money you have, but they don't really tell you what happens when something changes. You might have enough money in your checking account right now, but what if your car breaks down tomorrow? Can you still afford rent? Will you have to push back that trip you've been saving for?

We also noticed that financial news is usually presented in a way that doesn't mean much to the average person. A headline about rising gas prices might sound important, but how much does it actually affect your spending?

We wanted to build something that goes beyond tracking money and helps people understand how their financial decisions could affect their future. That's where Canopy came from. The name also ties into our idea of making financial goals feel like something you can actually watch grow.

What it does

Canopy is a mobile app that helps users understand their finances, prepare for unexpected expenses, and see how different decisions could affect their savings.

Instead of just showing account balances, Canopy lets users explore different financial scenarios and compare what could happen next.

Some of the main features include:

Financial Overview: Uses Capital One's Nessie API to retrieve synthetic banking data and display available account balances, expenses, and other financial information in one place.
Predict: Users can simulate unexpected events, like a $2,400 car repair or a temporary loss of income, and see how those expenses could affect their finances over time.
What If: Users can test how changing their spending habits might help them recover from an unexpected expense. Canopy compares three possible outcomes: their original financial situation, what happens after the event, and what happens if they make an adjustment.
Headline Impact: Users can enter financial news headlines, and Canopy checks whether the event could affect their finances based on the banking information available. If there isn't enough information to calculate an impact, the app explains what's missing instead of making up a number.
Goals: Users can track savings goals and see estimated completion dates when enough information is available. We also added a small garden where their progress is represented by growing plants, making saving feel a little more rewarding.

For example, if someone suddenly has a $2,400 car repair, Canopy can show how that expense changes their projected cash balance. They can then test something like spending $250 less per month and compare the results over the next year.

The idea is pretty simple: instead of just telling someone to save more money, we wanted to show them what difference that decision could actually make.

How we built it

We built Canopy as a mobile application using React Native, Expo, and TypeScript, with Expo Router for navigation and Zustand for managing application state. We also used React Native SVG and Reanimated for the financial charts and garden animations.

For the backend, we used Python and FastAPI to handle requests, process banking information, and run financial projections.

We integrated Capital One's Nessie API to retrieve synthetic banking data, including available accounts, transactions, deposits, and bills. We then built a projection engine that uses this information, along with user-provided assumptions, to estimate how someone's finances could change over time.

One important part of the backend is that all three scenarios start from the same financial snapshot. This allows us to compare the effect of an unexpected expense and a possible response without changing the starting data.

We also used MongoDB to store application-specific information such as savings goals and saved scenarios.

For headline analysis, we used financial rules and available spending data to determine whether an event could be modeled. We focused on separating actual banking data from hypothetical assumptions so users could understand where the numbers came from.

Challenges we ran into

One of our biggest challenges was working with the Nessie API. Since we're using synthetic banking data, some customers don't have enough transaction history to reliably estimate recurring income or spending. We had to figure out how to handle missing information without presenting inaccurate projections. We ended up allowing users to provide their own estimates when needed and clearly labeling those values as assumptions.

Another challenge was figuring out how to make the financial predictions useful. Initially, we were focused on displaying projected balances, but we realized that simply showing someone they might lose money wasn't very helpful. We needed to give users a way to actually respond to the problem. That led us to focus on comparing the baseline, the unexpected event, and the user's response side by side.

We also struggled with scope. We had a lot of ideas, from analyzing financial headlines to comparing financial products, but we only had a limited amount of time. We had to prioritize the features that worked together and made the core idea of Canopy clear.

On the frontend, getting the charts and animations to work smoothly on mobile took more effort than we expected, especially while keeping everything readable and consistent across different screens.

Accomplishments that we're proud of

One thing we're really proud of is getting the frontend, backend, and Nessie API working together to generate financial projections from actual sandbox data rather than hardcoded account balances.

We're also proud of the three-way comparison feature. For one of our tested scenarios, we simulated a $2,400 car repair and then a $250 monthly spending reduction. Over a 12-month projection, that spending adjustment improved the projected ending cash by $3,000 compared to the repair-only scenario. Being able to see that difference made the whole concept feel much more useful.

Another thing we're proud of is the design. We didn't want Canopy to feel like another complicated banking dashboard filled with numbers. We wanted it to be approachable while still giving users meaningful financial information. The garden might be a small feature, but it gave the app some personality and connected everything back to the idea of growing toward your goals.

What we learned

The biggest thing we learned is that having more features doesn't automatically make a better product. We started with a lot of different ideas, but the project became much clearer once we focused on one question: What happens to my money if something goes wrong, and what can I do about it?

We also learned how difficult it is to work with financial data that isn't always complete. Just because an API returns a balance doesn't mean we have enough information to predict someone's financial future. We had to think more carefully about assumptions, missing data, and how to communicate uncertainty.

On the technical side, we got more experience integrating external APIs, building financial calculations in Python, connecting a React Native frontend to FastAPI, and managing data across different parts of an application.

Most importantly, we learned that the way you present information matters just as much as the calculations behind it. A forecast is only useful if someone can understand what it means and what they can do with it.

What's next for Canopy

There are a few things we'd like to improve if we continue working on Canopy.

First, we'd like to integrate real financial accounts through a secure banking integration instead of relying on synthetic data. That would make the projections more useful and allow us to work with more complete transaction histories.

We also want to improve the projection engine by accounting for more uncertainty, rather than relying mainly on fixed assumptions. Exploring approaches like Monte Carlo simulations could help us show a range of possible outcomes instead of just one projected path.

Another feature we'd like to expand is headline analysis. Right now, the app needs relevant financial information and assumptions to calculate how a headline might affect someone. We'd like to support more types of events and eventually notify users when something could affect their savings goals.

Finally, we'd like to test Canopy with actual users to see which features they find useful and where the experience could be simpler.

Our long-term goal is to make Canopy something people can use not just to see where their money is today, but to feel more prepared for whatever happens next.