DogGo was inspired by the idea of providing a simple and intuitive platform for users who face the choice of paying bills or taking care of their pet. It's never an easy decision letting a family member go, but when it comes to the line, DogGo ensures that givers will be sending their loved ones off to another wonderful family.

What it does

DogGo allows registrations from two groups of people: Givers and Adopters. Givers are the individuals in the unfortunate situation of needing to let their pet go, and Adopters are the groups looking to temporarily foster or adopt them. Givers register their pets as available. When an Adopter signs up they have the choice to either input some specific information about what type of pet they're looking for, or simply upload a picture of the type of animal they're looking for. No matter what they do -- DogGo's Artificial Intelligence service will serve up any exact matches and suggested inquiries and provide ways for the Adopter to reach out and establish contact.

How I built it

The platform has three main components. The first is a web interface, which is built using HTML and CSS/JavaScript. The "logical heavy lifting" / backend is done via a Flask Python Server. It interfaces with the Firebase database, returning information to the web server to display when necessary. The Flask Server additionally handles all of our calculations, including determining what "exact" and "recommended" matches are.

Challenges I ran into

Of our group, most of us were more comfortable with iOS and Android development but had little experience developing web applications. Because of this, we decided to push our limits and create a website. We encountered numerous issues within the website itself, especially around trying to transfer large amounts of data between different pages. Formatting and styling the website additionally proved to be a difficult task.

Our backend also proved to have quite a few difficulties. Transferring data between the Flask Server and the Web application had copious bugs at first, with things as simple as mis-casing, random unicode characters and spacing preventing the transfer of data between the two platforms. Once we were able to resolve this issue, however, our progress in the back-end became much more fluent.

We additionally spent some time comparing and debating between the different types of database backends. We finally decided on Firebase after researching its extensive documentation, simplicity of its use and API, and the free hosting provided by Google.

Accomplishments that I'm proud of

We are incredibly proud of DogGo. Our team firmly believes that shelters are burdened enough as-is, and don't need the extra responsibility of facilitating foster and adoption processes. By introducing this venue as a home-to-home foster and adoption platform, we hope to reduce the number of pets entering shelter care in the long run.

We were additionally very excited about implementing an "external" backend to host the "brains" behind our application. Our thinking behind this decision is that it would allow for a simple integration of our application to other devices such as an iPhone or Android -- Instead of needing to re-create our logic in a new environment and update it in numerous places each time we needed to tweak, we now had one central system where all devices would reach out for data and analysis. While we unfortunately did not end up having the time to create iPhone and Android counterpart devices, we believe that the backend system is a great proof-of-concept and wouldd work if we decided to eventually implement them.

What I learned

One of the biggest takeaways is the difficulty involved with designing a simple and good-looking user interface. A lot of time went into our home-page and as a result it looks great, but it is static content. When it comes to our result page, we found it a lot more difficult to arrange and display all the relevant data in the same beautiful manner we did earlier.

Regarding the backend, our team struggled with coming up with a simple and efficient method of determining matches. Our initial prototypes use a polynomial runtime and iterate through the entire Firebase database. While it may work for our proof-of-concept prototype this weekend, the efficiency falls off as the size of the database increases and likely would not succeed long-term in a production environment with a large number of users. Being able to efficiently and effectivelyy traverse and analyze data is incredibly important in any application, and we definitely made some major improvements on that front.

What's next for DogGo

The current model of DogGo is extremely basic. Only the truly "core" features are present -- And there's so much more we want to add. From in-house methods of communication to actually setting up and overseeing the transition process between the giver and the adopter, we want DogGo to revolutionize the adoption process and provide a venue of support for families who can no longer afford to look after their loved pets.

Share this project: