Healthie Review as if it’s a cake
We decided to make this review a bit more fun and compare Healthie to a cake because, like a great cake, it has layers. And honestly, who doesn’t love a piece of cake? Each step, challenge, and success in our integration journey added its own unique flavor to the overall experience. Some layers were sweet and smooth, while others had a bit of crunch or unexpected spice. Here’s a slice-by-slice breakdown of our integration journey, complete with all the flavors we encountered along the way.
Project Goals
Zuri is an app dedicated to reproductive health & IVF treatment, and integrating Healthie is the heart of it. Healthie is the cornerstone of our application with a few additional features built on top of it.
Healthie provides extensive tools for various healthcare providers, but we needed to fine-tune it specifically for reproductive health. Our challenge was to incorporate Healthie’s telemedicine capabilities and offer unique features tailored to Zuri’s needs.
- fine-tune Healthie specifically for reproductive health
- Incorporate Healthie’s telemedicine capabilities into Zuri
- Build unique features on top of Healthie integration
Choosing Healthie for our EHR integration wasn’t just a random choice. Our client already had specific agreements with Healthie, making it a natural fit. As we dug deeper, we realized how powerful Healthie’s backend and frontend tools are, how simple it was to configure, and how supportive their team was. Our journey with Healthie had its ups and downs, but in the end, it was a valuable learning experience that taught us a lot about integrating complex EHR systems.
The Layers of our Cake
Powerful Tools and Flexibility (Vanilla Frosting Layer)
The platform lets both backend and frontend developers work directly with it. That’s the major advantage, and it’s not typical for many platforms.
Thanks to GraphQL, Healthie allows seamless integration with both mobile apps and web interfaces. This means developers have a full toolkit at their disposal, making it super convenient to create a cohesive and functional app. For Zuri, this flexibility and power in integration tools made Healthie an excellent fit.
Ease of Setup (Chocolate Ganache Layer)
Healthie provides configurations in both their UI and API. In practice, this meant our Product Owners could tweak settings using simple interface, our QA engineers could run various tests. Meanwhile, developers could dive into deeper customizations. This user-friendly setup process saved us a lot of time and effort.
Exceptional Support with Open Loop (Strawberry Jam Layer)
We worked with Open Loop Health, a telehealth support company & Healthie partnership company. Their support was outstanding. We had direct contacts for integration and even financial consultation, which was crucial for implementing Stripe as the primary payment system. It also included assistance with insurance payments, which is very helpful.
HIPAA compliant by default (Sticky Toffee Layer)
Healthie is well-known EHR, naturally, it is HIPAA-compliant right out of the box. Anyone who works with Healthcare apps, knows that HIPAA compliance is essential, this means that dev team needs to ensure that data storage and transmission are secure.
With Healthie, most patient data stayed on their platform, while we store only a minimal amount of data. This setup allows any collaborating doctor to access all necessary patient information and test results through Healthie.
Doctors can access this data via the UI, enabling instant two-way information exchange. For instance, as soon as we receive test results from a third-party provider, they are automatically available in Healthie. The doctor logs in, reviews the tests, writes recommendations, and the user receives a push notification. This system ensures maximum information circulation, all centered around Healthie.
Predictability and Sandbox Environment (Chewy Caramel Layer)
Healthie proved to be a reliable and predictable tool throughout the integration. Their sandbox environment allowed us to test queries and see the responses right in the user interface. This feature, which isn’t always common among similar tools, made our work much easier and more efficient. Being able to experiment and see immediate results in a controlled environment was incredibly helpful.
Compliance with Stripe (Lemon Curd Layer)
Healthie has a unique approach to Stripe. They have already gone through compliance with Stripe. When Stripe is set up, they act as the platform account, and when others connect to them, they provide their connected account. Essentially, we were already operating as people with a connected account. This created some inconveniences, but they were manageable once we got used to them.
Payments setup wasn’t as effortless as you would think. We’ve consulted with a few finance consultants. Unfortunately, they couldn’t answer all our questions, and we got stuck at this stage. It was a problematic nuance. As a result, we had to reconfigure our Stripe accounts, which led to a lack of understanding as to why we were doing it and extended the payment setup time.
The Layers with Some Extra Crunch
Access Challenges (Nutty Nougat Layer)
Healthie defaults to pretty tight security settings, which is great for protection but not so great when you’re trying to get things done quickly. They work by the principle “limit everything possible, sort out issues if they arise later’. We had to request additional access levels multiple times, which slowed us down. While this high security is understandable and essential, it did create some bumps in our integration journey.
Small Documentation Gaps (Almond Crunch Layer)
The documentation provided by Healthie was good but not perfect. It didn’t always cover all the use cases we needed, which led to some unexpected behaviors. For instance, when we sent API requests. Not everything worked as described, and we had to do a bit of trial and error to figure things out.
Two environments, not three (Crumbly Biscuit Layer)
In most products, there are usually three environments: staging, development, and production. Healthie provides staging and production environments, while development is used internally for their own development work. As an organization that uses all three environments, we needed the same three environments on their side. We resolved this issue by creating two different accounts and two different organizations within their staging environment. This is a standard practice for most companies developing applications.
File Handling Issues & Surveys (Spicy Cinnamon Layer)
Healthie’s GraphQL interface isn’t too convenient for files handling. Honestly, it took us some time to finally fix all file issues. Healthie imposed limits for file sizes, and specific handling methods in place. To work around these issues, we had to send requests to Open Loop for assistance.
We couldn’t upload a default element for all users, for instance a survey we wanted in the needed format. We worked with surveys in Heathie, but they had in-built limitations.
We also tried to configure certain things ourselves. If we didn’t receive a timely response from Open Loop, we would attempt to apply other elements that could replace the basic ones. For example, we had a situation where we couldn’t process a certain type of document, so we decided that each doctor would upload this element with a specific name convention.
In Healthie, files categorization didn’t fit our needs; you can upload documents, but it doesn’t distinguish between different types like test results or patient documents. It didn’t categorize them into subtypes. Therefore, we had to come up with our own naming convention so that we could automate this process in the future.
Baking Lessons Learned
Integrating Healthie into Zuri was like baking a multi-layer cake, each layer adding its own unique flavor to the experience. There are some baking lessons, we’d love to outline.
Take enough time to learn Healthie
One of the biggest takeaways was the importance having more initial calls with Open Loop and Healthie’s technical team from the get-go. It would have saved us a lot of back-and-forth and potential delays.
We also learned that a thorough review of all provided documentation before diving into the integration is essential. This helps in identifying any gaps or potential issues early on, allowing time to seek clarification and avoid mid-project surprises.
Make sure your team member have experience with HIPAA
Having team members with prior experience in HIPAA compliance is a huge advantage. The intricacies of HIPAA compliance bring numerous constraints and understanding them well in advance can streamline the process significantly.
Healthie is a powerful tool, which we loved working with.
Long story short, we absolutely loved working with Healthie. The robust tools, easy setup, and top-notch support were real game-changers for us. Sure, we hit some bumps along the way—like access challenges, file handling quirks, and a few documentation gaps—but those just added to the learning experience.
Are you curious to learn more about our healthcare expertise and projects? Look no further! Read about Fulcrum Healthcare expertise.
