## Inspiration

We have a problem! We have a new generation of broke philanthropists.

The majority of students do not have a lot of spare cash so it can be challenging for them to choose between investing in their own future or the causes that they believe in to build a better future for others.

On the other hand, large companies have the capital needed to make sizeable donations but many of these acts go unnoticed or quickly forgotten.

## What it does

What if I told you that there is a way to support your favourite charities while also saving money? Students no longer need to choose between investing and donating!

Giving tree changes how we think about investing. Giving tree focuses on a charity driven investment model providing the ability to indulge in philanthropy while still supporting your future financially.

We created a platform that connects students to companies that make donations to the charities that they are interested in. Students will be able to support charities they believe in by investing in companies that are driven to make donations to such causes.

Our mission is to encourage students to invest in companies that financially support the same causes they believe in. Students will be able to not only learn more about financial planning but also help support various charities and services.

## How we built it

### Backend

The backend of this application was built using python. In the backend, we were able to overcome one of our largest obstacles, that this concept has never been done before! We really struggled finding a database or API that would provide us with information on what companies were donating to which charities.

So, how did we overcome this? We wanted to avoid having to manually input the data we needed as this was not a sustainable solution. Additionally, we needed a way to get data dynamically. As time passes, companies will continue to donate and we needed recent and topical data.

Giving Tree overcomes these obstacles using a 4 step process:

1. Using a google search API, search for articles about companies donating to a specified category or charity.
2. Identify all the nouns in the header of the search result.
3. Using the nouns, look for companies with data in Yahoo Finance that have a strong likeness to the noun.
4. Get the financial data of the company mentioned in the article and return the financial data to the user.

This was one of our greatest accomplishments of this project. We were able to overcome and obstacle that almost made us want to do a different project. Although the algorithm can occasionally produce false positives, it works more often than not and allows for us to have a self-sustaining platform to build off of.

### Flask

```shell script
$ touch application.py

from flask import Flask
application = Flask(**name**)
@application.route('/')
def hello\_world():
 return 'Hello World'

```
```shell script
$ export FLASK_APP="application.py"
$ flask run

```

Now runs locally:

<http://127.0.0.1:5000/>

### AWS Elastic Beanstalk

Create a Web Server Environment:
```shell script
AWS -> Services -> Elastic beanstalk
Create New Application called hack-western-8 using Python
Create New Environment called hack-western-8-env using Web Server Environment

```
### AWS CodePipeline

Link to Github for Continuous Deployment:
```shell script
Services -> Developer Tools -> CodePipeline
Create Pipeline called hack-western-8
GitHub Version 2 -> Connect to Github
Connection Name -> Install a New App -> Choose Repo Name -> Skip Build Stage -> Deploy to AWS Elastic Beanstalk

```

This link is no longer local:

<http://hack-western-8-env.eba-a5injkhs.us-east-1.elasticbeanstalk.com/>

### AWS Route 53

Register a Domain:
```shell script
Route 53 -> Registered Domains -> Register Domain -> hack-western-8.com -> Check
Route 53 -> Hosted zones -> Create Record -> Route Traffic to IPv4 Address -> Alias -> Elastic Beanstalk -> hack-western-8-env -> Create Records
Create another record but with alias www.

```
Now we can load the website using:<br/>
[hack-western-8.com](http://hack-western-8.com)<br/>
www.hack-western-8.com<br/>
http://hack-western-8.com<br/>
http://www.hack-western-8.com<br/>
Note that it says "Not Secure" beside the link<br/>

### AWS Certificate Manager

Add SSL to use HTTPS:
```shell script
AWS Certificate Manager -> Request a Public Certificate -> Domain Name "hack-western-8.com" and "*.hack-western-8.com" -> DNS validation -> Request
$ dig +short CNAME -> No Output? -> Certificate -> Domains -> Create Records in Route 53
Elastic Beanstalk -> Environments -> Configuration -> Capacity -> Enable Load Balancing
Load balancer -> Add listener -> Port 443 -> Protocol HTTPS -> SSL certificate -> Save -> Apply

```

Now we can load the website using:

<https://hack-western-8.com>

<https://www.hack-western-8.com>

Note that there is a lock icon beside the link to indicate that we are using a SSL certificate so we are secure

## Challenges we ran into

The most challenging part of the project was connecting the charities to the companies. We allowed the user to either type the charity name or choose a category that they would like to support. Once we knew what charity they are interested in, we could use this query to scrape information concerning donations from various companies and then display the stock information related to those companies. We were able to successfully complete this query and we can display the donations made by various companies in the command line, however further work would need to be done in order to display all of this information on the website. Despite these challenges, the current website is a great prototype and proof of concept!

## Accomplishments that we're proud of

We were able to successfully use the charity name or category to scrape information concerning donations from various companies. We not only tested our code locally, but also deployed this website on AWS using Elastic Beanstalk. We created a unique domain for the website and we made it secure through a SSL certificate.

## What we learned

We learned how to connect Flask to AWS, how to design an eye-catching website, how to create a logo using Photoshop and how to scrape information using APIs.

We also learned about thinking outside the box. To find the data we needed we approached the problem from several different angles. We looked for ways to see what companies were giving to charities, where charities were receiving their money, how to minimize false positives in our search algorithm, and how to overcome seemingly impossible obstacles.

## What's next for Giving Tree

Currently, students have 6 categories they can choose from, in the future we would be able to divide them into more specific sub-categories in order to get a better query and find charities that more closely align with their interests.

Health
 - Medical Research
 - Mental Health
 - Physical Health
 - Infectious Diseases

Environment
 - Ocean Conservation
 - Disaster Relief
 - Natural Resources
 - Rainforest Sustainability
 - Global Warming

Human Rights
 - Women's Rights
 - Children

Community Development
 - Housing
 - Poverty
 - Water
 - Sanitation
 - Hunger

Education
 - Literacy
 - After School Programs
 - Scholarships

Animals
 - Animal Cruelty
 - Animal Health
 - Wildlife Habitats

We would also want to connect the front and back end.
# Course Connection

## Inspiration

College is often heralded as a defining time period to explore interests, define beliefs, and establish lifelong friendships. However the vibrant campus life has recently become endangered as it is becoming easier than ever for students to become disconnected. The previously guaranteed notion of discovering friends while exploring interests in courses is also becoming a rarity as classes adopt hybrid and online formats. The loss became abundantly clear when two of our members, who became roommates this year, discovered that they had taken the majority of the same courses despite never meeting before this year. We built our project to combat this problem and preserve the zeitgeist of campus life.

## What it does

Our project provides a seamless tool for a student to enter their courses by uploading their transcript. We then automatically convert their transcript into structured data stored in Firebase. With all uploaded transcript data, we create a graph of people they took classes with, the classes they have taken, and when they took each class. Using a Graph Attention Network and domain-specific heuristics, we calculate the student’s similarity to other students. The user is instantly presented with a stunning graph visualization of their previous courses and the course connections to their most similar students.

From a commercial perspective, our app provides businesses the ability to utilize CheckBook in order to purchase access to course enrollment data.

## High-Level Tech Stack

Our project is built on top of a couple key technologies, including React (front end), Express.js/Next.js (backend), Firestore (real time graph cache), Estuary.tech (transcript and graph storage), and Checkbook.io (payment processing).

## How we built it

### Initial Setup

Our first task was to provide a method for students to upload their courses. We elected to utilize the ubiquitous nature of transcripts. Utilizing python we parse a transcript, sending the data to a node.js server which serves as a REST api point for our front end. We chose Vercel to deploy our website. It was necessary to generate a large number of sample users in order to test our project. To generate the users, we needed to scrape the Stanford course library to build a wide variety of classes to assign to our generated users. In order to provide more robust tests, we built our generator to pick a certain major or category of classes, while randomly assigning different category classes for a probabilistic percentage of classes. Using this python library, we are able to generate robust and dense networks to test our graph connection score and visualization.

### Backend Infrastructure

We needed a robust database infrastructure in order to handle the thousands of nodes. We elected to explore two options for storing our graphs and files: Firebase and Estuary. We utilized the Estuary API to store transcripts and the graph “fingerprints” that represented a students course identity. We wanted to take advantage of the web3 storage as this would allow students to permanently store their course identity to be easily accessed. We also made use of Firebase to store the dynamic nodes and connections between courses and classes.

We distributed our workload across several servers.
We utilized Nginx to deploy a production level python server that would perform the graph operations described below and a development level python server. We also had a Node.js server to serve as a proxy serving as a REST api endpoint, and Vercel hosted our front-end.

### Graph Construction

Treating the firebase database as the source of truth, we query it to get all user data, namely their usernames and which classes they took in which quarters. Taking this data, we constructed a graph in Python using networkX, in which each person and course is a node with a type label “user” or “course” respectively. In this graph, we then added edges between every person and every course they took, with the edge weight corresponding to the recency of their having taken it.

Since we have thousands of nodes, building this graph is an expensive operation. Hence, we leverage Firebase’s key-value storage format to cache this base graph in a JSON representation, for quick and easy I/O. When we add a user, we read in the cached graph, add the user, and update the graph. For all graph operations, the cache reduces latency from ~15 seconds to less than 1.

We compute similarity scores between all users based on their course history. We do so as the sum of two components: node embeddings and domain-specific heuristics. To get robust, informative, and inductive node embeddings, we periodically train a Graph Attention Network (GAT) using PyG (PyTorch Geometric). This training is unsupervised as the GAT aims to classify positive and negative edges. While we experimented with more classical approaches such as Node2Vec, we ultimately use a GAT as it is inductive, i.e. it can generalize to and embed new nodes without retraining. Additionally, with their attention mechanism, we better account for structural differences in nodes by learning more dynamic importance weighting in neighborhood aggregation. We augment the cosine similarity between two users’ node embeddings with some more interpretable heuristics, namely a recency-weighted sum of classes in common over a recency-weighted sum over the union of classes taken.

With this rich graph representation, when a user queries, we return the induced subgraph of the user, their neighbors, and the top k most people most similar to them, who they likely have a lot in common with, and whom they may want to meet!

## Challenges we ran into

We chose a somewhat complicated stack with multiple servers. We therefore had some challenges with iterating quickly for development as we had to manage all the necessary servers.
In terms of graph management, the biggest challenges were in integrating the GAT and in maintaining synchronization between the Firebase and cached graph.

## Accomplishments that we're proud of

We’re very proud of the graph component both in its data structure and in its visual representation.

## What we learned

It was very exciting to work with new tools and libraries. It was impressive to work with Estuary and see the surprisingly low latency. None of us had worked with next.js. We were able to quickly ramp up to using it as we had react experience and were very happy with how easily it integrated with Vercel.

## What's next for Course Connections

There are several different storyboards we would be interested in implementing for Course Connections. One would be a course recommendation. We discovered that chatGPT gave excellent course recommendations given previous courses. We developed some functionality but ran out of time for a full implementation.
## Inspiration

As high school seniors on the cusp of a new academic journey, we realized the looming academic expenses that are associated with attending college. In order to simplify navigating the maze of college finances we created **‘brokemenot.us’**, a website for college students to explore the financial space. We envisioned this tool to alleviate these financial pressures by providing budgeting tools, financial literacy courses/blogs, bank account management, a budgeting system as well as a student loan management/acquisition system.

## What it does

**‘brokemenot.us’** is a web application that provides college students with a way to manage their finances simply. The application allows students to connect their Capital One account, or create a new one entirely, through the Nessie API. Then through the account information available students are able to view their balance, transactions, and bills. This along with our budgeting/financial management system allows students to easily track their expenditures and see if they stay within their determined budget. Additionally, the app includes coursework in the form of articles and blogs to increase the student’s financial literacy. Finally, there is a student loan finder for the students based on their financial information. While Capital One accounts have an in-built loan option, students also have access to other financial aid methods.

## How we built it

For the frontend, we used Taipy, a framework which allowed us to build a website in Python. The framework allowed us to build a very elegant and user-friendly interface. Thanks to the aforementioned framework, we built the backend using Python too. This allowed us to incorporate the powerful APIs of Twilio and Capital One! We were able to embed products from the Google Suite to enhance user experience. We also were able to use a GoDaddy domain to make our site easier to access across the globe.

## Challenges we ran into

We had a great deal of difficulty getting accustomed to the Taipy web framework. Taipy allows for robust full stack web development solely in Python, simplifying the development process. However, us being used to traditional development using HTML, CSS, JS, and frameworks such as React, we found it difficult to adopt this new style of working. Firstly, we had to make the decision of using Taipy’s own Markdown for the UI or HTML. Being experienced with HTML, we went with that, but we quickly found that the documentation didn’t include all we needed it to. Furthermore, Taipy, being a framework on the rise, there wasn’t a large community of developers to turn to with questions. However, after much effort, we were able to effectively use the Taipy framework, and we thought it was a great way to have all of our code in one, organized place. We are proud of ourselves for learning a new skill, and we see ourselves using Taipy for future endeavors.

## Accomplishments that we're proud of

We are really proud of what we have accomplished during this hackathon. Firstly, we are proud that we managed to utilize Taipy, a new and unique framework that none of us have ever heard of before. We are proud that we were able to incorporate many additional features such as Capital One and Twilio API! While we have a lot of work to do if we want to perfect our project, we are proud of what we have completed within the given timeframe. And most importantly, we enjoyed every minute of our time on the UPenn campus.

## What we learned

Through the past 36 hours, we’ve used several technologies that we previously have not used. We utilized Twilio, Capital One Nessie API, GoDaddy, Taipei as well as GoDaddy. To use these new technologies we had to learn new skills. Solely through the documentation for each, we navigated through its uses and features to produce a complex application.

## What's next for BrokeMeNot

Our goal is to make it even more user-friendly for future college-going students. We would like to move away from the embedded Google Suite products to make our site more convenient and interactive. One of our goals going into the website was to incorporate an AI Chatbot of sorts in our website to help guide students searching for resources or options. Additionally, we wish to include AI-generated personal recommendations for the user based on their financial situation. While we did not have enough time to implement it, we would like to implement it in the future.