Shop Alto Essentials to add pharmacy products to any delivery!

Your partner in navigating the ins and outs of prescriptions — at no extra cost.

Alto Pharmacy Technician

Alto Pharmacist

It’s official: Alto Pharmacy is a great place to work! We’re honored to join the community of Great Place to Work-Certified™ companies based on team member feedback and a rigorous assessment of our company’s culture and benefits.

Join us in delivering our industry-leading pharmacy care to millions of people across the country. As a member of the team, you’ll play an integral role in improving our customers’ quality of life and redefining what’s possible in pharmacy. 

Be Part of a Great Place to Work — Join Our Team

Hear first-hand from members of the Alto technology teams.

Read the latest Alto blog posts covering healthcare, family health, managing diseases, and other Alto highlights.

Blog | Alto Pharmacy

The United States continues to make meaningful progress with HIV prevention efforts, as recently released CDC data shows that new infections fell by 12% from 2017 to 2021. Notably, new infections among 13- to 24-year-olds were 34% lower in 2021, contributing significantly to the overall decline.

PrEP Drives Decline in New HIV Infections

The numbers reflect an increase in usage of the HIV prevention medication PrEP — an acronym for pre-exposure prophylaxis — which can lower the risk of sexual transmission by about 99% when taken as prescribed. It is typically recommended for people whose partner is HIV-positive or unsure of their HIV status. 30% of the 1.2 million individuals who could benefit from PrEP were prescribed it in 2021, the CDC reports, in contrast to 13% in 2017.

Despite these gains, HIV continues to disproportionately affect people of color, with the decline in new annual infections lower among young Black and Latinx gay and bisexual men. Equity in HIV prevention is an established challenge. According to 2016 CDC data, white individuals accounted for 69% of PrEP use, while Black and Latinx individuals accounted for 13% and 11%, respectively. The CDC’s latest numbers suggest that PrEP remained underutilized among Black and Latinx people in 2021, indicating that prevention and treatment are not reaching all racial and ethnic groups equitably.

Cost is often a barrier to starting PrEP, but thanks to financial resources and expanded insurance coverage, the medication continues to become more affordable. To learn more about accessing PrEP at the best price, read our post on PrEP affordability resources for all insurance statuses here. You can also take a closer look at state patient assistance programs here.

You can get a prescription for PrEP from your doctor. If you do not have a provider or are unable to get a prescription from them, the resources below can connect you with a PrEP prescriber. Note that negative HIV test results are required to begin taking PrEP, and ongoing medical care, including routine tests for HIV and other sexually transmitted infections (STIs), is required to continue treatment.

Expert Pharmacist Support for PrEP Treatment

Alto will coordinate with your doctor and your insurance provider to ensure you’re receiving the best PrEP option for your needs at the most affordable price. We offer delivery right to your doorstep, with discrete, private packaging. The app offers a direct line to pharmacists with expertise in HIV treatment and prevention, as well as reminders to help you stay on track.

Interested in learning more about how Alto can support your PrEP treatment? Reach out through secure in-app messaging.

This content is not intended to be a substitute for professional medical advice, diagnosis, or treatment. Always seek the advice of your physician or another qualified health provider with any questions you may have regarding a medical condition.

Staying on track with treatment and fully benefiting from a medication entails more than simply filling a prescription. It requires patients to take an active role in their health journeys, with education, clinical monitoring, and side effect management all necessary for proper drug utilization.

How Alto’s High-Touch Model Supports Patient Engagement

Pharmacists are an invaluable healthcare resource for those with complex treatment plans. Unfortunately, the traditional retail and mail-order models fail to maximize the possibilities of pharmacy care, without opportunities for ongoing engagement with patients. Not only are retail pharmacists often inundated with many tasks, it’s difficult for patients to discuss their health in a crowded store with a line of other customers behind them. And patients receiving their medication by mail often have limited visibility into delivery details or difficulty connecting with the pharmacy team. 

Alto Pharmacy offers a supported and convenient prescription journey at every step. We ensure that our patients have the information they need to get started with specialty medications and feel confident about their care. In addition to providing a simple onboarding experience, we have a team with robust clinical expertise and a high-touch model that allows patients to easily benefit from it.

We are also expanding our reach to fertility patients through our new nationwide* mail-order offering. Patients who receive fertility medications through mail-order experience the same convenience and support as those we serve via local courier delivery, with seamless onboarding, easy and supported medication management, and access to experts. 

And with an integrated and customizable tech stack — including both our proprietary pharmacy management software and our patient app — there are many ways for partners to provide additional engagement and supplement other support programs.

Here’s how Alto’s model enhances medication education and gives you, as a partner, the opportunity to more deeply engage our shared patients.

Alto offers a supportive and simple patient onboarding experience with proactive multichannel communication. We give patients a welcome text or call within 60 minutes of receiving their prescription, guiding them through their first order. Those who need to transfer an existing prescription to Alto can do so within minutes in our app.

If more information is necessary to fill a prescription, we make sure that patients and providers are both fully in the loop. We keep the patient informed at every step of the billing process, offering support with prior authorizations as needed. Through Alto Connect, our free communications portal for providers, clinical teams can view active medication details and quickly understand when additional steps are required to fill a prescription.

Partner Opportunities to Supplement Patient Support

The majority of Alto patients use our app for intake, medication ordering, and delivery scheduling. Not only does this give patients control and convenience in managing their prescriptions, it provides opportunities for additional engagement from partners.

Our flexible technology capabilities allow for many possibilities, including in-app introductions to your medications. In this video, a specialist from our fertility team walks patients through injecting the Gonal-f® RFF Redi-ject® Pen.

Follow-Up and Improving the Patient Experience

Easy onboarding is just the beginning. Alto supports patients at every stage of the prescription journey so that they can get the most benefit from their medication. Our dedicated medication therapy management pharmacists, who focus entirely on disease state education and support for chronic conditions, proactively contact patients who take specialty medications to review their regimens.

We ask if they are experiencing any side effects and track all patient-reported outcomes. As a partner, you can have access to data and insights into your patients’ experience of your medications.

We’re also able to tailor a patient’s treatment to any titration schedule prescribed by their provider. In these cases, we inform the patient of this schedule and change in medication dosage at every step of the treatment.

We see our NPS of 88 as an attestation of our patients’ love and commitment to both Alto and their health. 

Choose Alto Pharmacy for your limited distribution network

Alto’s end-to-end dispensing model is specifically built for specialty and specialty lite products. To learn more about partnering with us, reach out to partnerships@alto.com.

All third party trademarks (including logos and icons) referenced by Alto Pharmacy remain the property of their respective owners. Unless specifically identified as such, Alto’s use of third party trademarks does not indicate any relationship, sponsorship or endorsement between Alto and the owners of these trademarks.

Tech-Based, High-Touch Patient Engagement at Alto

At Alto Pharmacy, a patient’s financial wellness is of the utmost importance. We understand that cost is one of the most common barriers to medication access, and we go above and beyond to connect patients with any savings opportunities that they may qualify for. 

Alto Pharmacy’s Product Controls for Coupons

At the same time, as a specialty pharmacy, we have a responsibility to protect the integrity of assistance programs and ensure that only eligible patients benefit from these resources. Our integrated technology stack provides the controls needed to restrict savings access to qualifying patients. Take a look.

The two components of Alto’s technology stack are both integral to our coupon controls.

Our proprietary pharmacy management software, Wunderbar — through which more than 80% of our prescriptions are automatically billed by algorithms — gives us both control and flexibility, with the ability to set custom workflows and requirements.

Our patient app — which the majority of Alto patients use for intake, medication ordering, and delivery scheduling — integrates with Wunderbar. With many areas for patient input, including coupon sign-ups, the app allows us to easily provide data to partners and further supports our controls.

Multiple guardrails for controlling coupon use

Our robust technology platform gives us multiple ways to ensure that coupons are applied to those who are eligible.

Providers often include ICD-10 diagnosis codes on prescriptions to aid in prior authorizations and coupon use. The provided information is entered into Wunderbar during our automated intake process. Our billing controls can limit coupon use to a specific diagnosis code if necessary, allowing for proper distribution of a medication. 

If a provider did not include the necessary diagnosis code for coupon verification, the patient can verify their diagnosis through the app. Our tech capabilities allow us to create pop-ups or notifications as needed for patient input. This patient attestation can be customized for different medication coupon scenarios and reported outcomes.

With a flexible tech stack, we can easily create additional workflows or automations to further regulate savings applications. These are some of the filters we can use:

Since we use proprietary software, we’re not only able to ensure appropriate application of savings opportunities — we have so much available data about coupon use to share with partners like you.

We can provide NDC and patient-level insights, including coupon application, the exact amount of money saved, and how many fills were delivered. These data insights could help develop market access strategies by monitoring gross to net gaps and identifying the opportunities for copay accumulators and maximizers.

At Alto Pharmacy, a patient’s financial wellness is of the utmost importance. We understand that cost is one of the most common barriers to medication access, and we go above and beyond to connect patients with any savings opportunities that they may qualify for. 

At the same time, as a specialty pharmacy, we have a responsibility to protect the integrity of assistance programs and ensure that only eligible patients benefit from these resources. Our integrated technology stack provides the controls needed to restrict savings access to qualifying patients. Take a look.

The Alto product and engineering team has long been focused on initiatives that improve our unit profitability. Now that we’ve laid a strong foundation, we've started to think about our next big bets: How do we expand our services beyond delivering prescriptions? How do we test new value-add offerings quickly and iteratively? That’s where the incubation team comes in.

Meet the Innovation Team Building Alto's Next Big Bets

The Alto product and engineering team has long been focused on initiatives that improve our unit profitability. Now that we’ve laid a strong foundation, we've started to think about our next big bets: How do we expand our services beyond delivering prescriptions? How do we test new value-add offerings quickly and iteratively? That’s where the innovation team comes in.

Newly launched in 2022, the team is small and scrappy by design. We’re a product manager, two engineers, a part-time designer, and a part-time manager with a single mission: to launch at least two significant new business experiments per year. If an experiment is successful, we’ll scale it into a full workstream before handing it off to a stand-alone product team.

We started with over-the-counter (OTC) medications. OTCs, or medications you can buy without a prescription, like Advil, are high-margin products that users are accustomed to purchasing at traditional, brick-and-mortar pharmacies. The goal of this experiment was to assess how much interest users have in adding OTCs to their order while checking out in the Alto app. We set a target conversion rate and offered OTCs only from our San Jose pharmacy, which is less busy than our San Francisco pharmacy but close enough to engineers in San Francisco for in-person troubleshooting.

Our initial hypothesis: if we present users with a small selection of OTCs targeted to their needs (based on the prescriptions in their cart), they’ll be more likely to convert. With support from our pharmacy partners, we carefully curated a recommendation algorithm that would suggest nine OTCs based on the medications already in the user’s cart.

In the interest of lean experimentation, we wanted a scrappy technical solution that could be implemented quickly while meeting our high user experience standards and minimizing operational risk. We settled on the following architecture:

We prioritized creating a clean API for Alto’s customer-facing app and using as much of our current infrastructure as possible. Although OTCs are distinct from prescriptions, we decided to reuse our existing prescription model rather than build a new one from scratch. This allowed us to leverage existing systems and operational workflows, reducing engineering time and risk of regression.

Behind the API, we opted to store our OTC formulary and associated metadata in in-memory data structures:

ADVIL = SkuId.new(sku: '...', sku_type: '...').freeze
CLARITIN = SkuId.new(sku: '...', sku_type: '...').freeze
FISH_OIL = SkuId.new(sku: '...', sku_type: '...').freeze
...
METADATA_BY_SKU_ID = {
  ADVIL.hash_code => {
    image_url: '...',
    name: 'Advil Ibuprofen 200mg Coated Tablets',
    quantity_description: '100 tablets',
    product_description: 'Easy to swallow powerful pain reliever for headaches, joint and muscle pain.',
  },
  CLARITIN.hash_code => {
    image_url: '...',
    name: 'Claritin 24 Hour Allergy Tablets',
    quantity_description: '30 tablets',
    product_description: 'Non-drowsy, 24 hour relief of symptoms due to allergies: sneezing, runny nose, itchy and watery eyes.',
  },
  FISH_OIL.hash_code => {
    image_url: '...',
    name: 'Fish Oil 500mg Softgels',
    quantity_description: '130 softgels',
    product_description: 'Dietary supplement with EPA and DHA omega-3 fatty acids to support heart health and maintain normal triglyceride levels.',
  },
  ...
}.freeze

This gave us a nice balance of speed and flexibility. We knew that we could optimize once we had established our OTC offering and gained an understanding of how it would evolve within Alto.

The results of phase 1 were a bit disappointing, but very interesting: the conversion rate of users who checked out with an OTC was just under our target. However, nearly half of all users who saw the experience would scroll down to peruse all nine OTCs that were offered.

Based on this positive sign of engagement, we hypothesized that perhaps we just weren’t showing the right OTC products to the user. For phase 2, we decided to scrap the limited recommendations and allow users to explore an entire catalog of OTCs.

Phase 2 required categorizing our list of OTCs into buckets such as “Top Sellers,” “Covid Care,” and “Allergy & Asthma.” We built a new fetch_categorized endpoint to return our OTC catalog structured by category, adding search functionality into the client so that users could quickly filter for a specific product. This search field was also heavily tracked with analytics events to help us learn which products to add to our catalog in the future.

This new experience immediately outperformed phase 1. After a few performance improvements (speeding up our catalog and product image load times), we eventually hit our target conversion rate — even managing to surpass it on some weeks!

Our eventing did show that a significant number of users with multiple prescriptions or smaller screens were not even seeing the OTCs in Cart, as they were pushed below the fold. We tried experimenting with alternate spots to show our catalog:

1. An interstitial that shows after Cart and before Checkout - this didn’t perform any better than the control and was quickly scrapped.

2. A single carousel at the top of Cart - this out-performed the control but at the cost of our guardrail metric. With a decrease in the overall checkout rate, we decided to stick with the control for now.

This phase of UI experimentation validated that our users wanted an offering of categorized OTCs. However, our initial technical solution wouldn’t scale as we rolled out to more of our pharmacies. The following questions led us to this conclusion.

How might we support changes to our OTC catalog on a per-pharmacy basis?

Given factors such as inventory, geography-related price sensitivities, and experimentation, we wanted to make sure that we could tweak the OTC experience for users getting deliveries from a specific pharmacy.

In the status quo implementation, that would have likely meant adding an additional layer to our data structures like so:

SKUS_BY_PHARMACY_AND_CATEGORY = {
  SF_PHARMACY_ID => [
    AddOnOtcCategoryType::TopSellers => [
      IHEALTH,
      FLONASE,
      ASPIRIN,
      ...
    ],
    ...
  ],
  ...
}

We weren’t worried about memory space limits given our relatively small number of pharmacies and OTC catalog. We were concerned, however, that each modification would require an engineer to go in and make code changes, get PR approval, and wait for a full deploy for the update to go live. This would be a bad use of engineering time, and our CI/CD process would become a bottleneck to otherwise quick modifications.

How might we add and remove OTCs from our catalog?

Similarly, we knew that adding and removing OTCs from our catalog would also be a somewhat regular workflow. There are some other considerations when adding a new OTC (Is it in our product database? Do we need any new procurement/inventory workflows to make sure it gets stocked in our pharmacies? Do we have a nice image to render in the app?), but we wanted to automate the technical side as much as possible — or at least be able to automate it.

The natural next step was to move our OTC catalog into the database.

Alto’s OTC Database Schema. Some columns excluded for brevity.

Now, rather than grabbing from in-memory data structures, we are efficiently querying the database for the OTC catalog of a user’s specific pharmacy, preloading all of the associated models needed for our API response.

OtcCategory
  .includes(otc_category_products: { otc_product: :otc_product_metadata })
  .where(otc_category_products: { pharmacy_id: pharmacy_id })
  .where(otc_product_metadata: { pharmacy_id: pharmacy_id })


At the time of writing, an engineer is still required to go in and make the changes at the database level. However, we plan to build an admin dashboard so that designated pharmacy partners can tweak our OTC catalog without the help of an engineer.

We’re excited about our next iteration, which will allow users to add OTCs to their upcoming deliveries at any point, not only when checking out. It will likely be live by the time you read this.

Once that’s released, we will continue to learn, iterate, and pay down technical debt — more specifically, maturing the OTC data model in our backend and eliminating the need for them masquerade as prescriptions.

Looking even further ahead, the innovation team has more exciting and impactful projects on our roadmap. We can’t wait to share what’s in store!

While fertility treatments like in vitro fertilization (IVF) have become an increasingly common path to parenthood, helping millions of individuals conceive throughout the past four decades, they remain a significant financial investment.

How Alto Lowers the Cost of Fertility Treatment Through Better Medication Management

Fertility medications used to support egg production, retrievals, and implantations frequently factor heavily into the overall cost of treatment. An average IVF cycle costs between $10,000 and $15,000, with medications an additional $5,000 or more depending on factors like a patient’s age and health history and a clinic’s treatment approach. Unfortunately, a portion of these medications often go unused, as many fertility treatment plans involve last-minute medication changes unsuited for the traditional retail pharmacy model.

As part of our commitment to your financial well-being, we offer a medication management experience that reduces fertility medication waste to lower the cost of treatment, developed in collaboration with Progyny. Take a closer look at our approach.

IVF is a process in which eggs and sperm are fertilized and then placed into the uterus with the potential outcome of a pregnancy. Multiple medications are used on a precisely timed schedule to grow follicles — fluid-filled sacs in the ovaries that potentially contain an egg — retrieve eggs, and, finally, implant a fertilized egg into the uterus. 

Here’s a snapshot of a typical IVF medication schedule:

Days 1-4: stimulation medications such as Gonal-f®, Follistim®, Menopur®, or Low-Dose hCG to stimulate egg production, so that you produce multiple follicles

Days 5-10: continuation of stimulation medications and introduction of antagonists such as Fyremadel™ (ganirelix acetate) and Cetrotide® to prevent premature ovulation

Days 10+: trigger shots of leuprolide acetate, Ovidrel®, and/or Novarel®/Pregnyl® to stimulate final growth spurt and ovulation

After transfer: estrogen and progesterone to support successful implantation of the embryo

Fertility medications are complex, with nightly dosages dependent upon hormone levels measured through bloodwork and ultrasounds. Not only do medication protocols vary from one individual to another, they are typically adjusted throughout the course of a cycle as hormones fluctuate.

Unused medication during fertility treatment

To prevent any missed doses, providers typically prescribe all medications that could be needed in bulk at the beginning of fertility treatment. However, dosages often decrease once a cycle is underway based on a provider’s discretion, ultrasounds, and bloodwork.

At traditional pharmacies, patients undergoing fertility treatment might end up paying for unused medication, as all potential medications are filled upfront. This contributes to the $5.4 billion epidemic of medication waste in the U.S. — one that is particularly acute in fertility, leading some individuals to buy and sell excess medication to each other on social media sites.

Our approach to fertility medication management

Alto has partnered with fertility benefits manager Progyny on an algorithm-powered, app-based medication management experience that reduces unneeded fertility medications while protecting the integrity of time-sensitive and personalized treatment plans.

First, we collect fertility cycle information through the Alto app and run the data through the Progyny algorithm to determine exactly what medication volumes are needed for the next phase of treatment. We then prepare a custom order for just the medications that are immediately needed, which are then delivered directly to your doorstep by our courier team. 

You will receive multiple deliveries throughout the course of your cycle, determined by your specific dosing, trigger schedule and other inputs from your clinical team. This approach allows you to manage your medications as your IVF cycle progresses, giving you more control over the total amount of medication that you fill.

Additional financial resources for fertility medications

Alto is committed to helping you save as much as possible on your fertility medications. In addition to our personalized medication management approach, we’ll automatically search for savings and connect you with programs that require you to apply directly, including patient assistance programs from fertility medication manufacturers.

If Alto is your fertility pharmacy, your fertility medication protocol likely includes medications manufactured by EMD Serono or Ferring Pharmaceuticals. EMD has several programs that lower the cost of fertility treatment, including the Compassionate Care program, which offers income-based assistance for fertility medications that aren’t covered by insurance, and special opportunities for military veterans and cancer survivors.

Ferring Pharmaceuticals also offers financial assistance programs to offset the cost of fertility medications, including the HeartTomorrow program for individuals who elect to freeze their eggs, and special opportunities for military veterans and cancer patients.

Read Managing the Costs of Fertility Treatment for more on Alto’s financial support for fertility treatment and medications.

Choose a flexible and reliable pharmacy partner

Fertility treatment can be challenging, but we’ll be with you every step of the way. To ensure that your treatment plan is followed correctly, we offer fast, reliable delivery of your medications and fertility resources like personalized injection guide videos and one-on-one consultations with fertility-trained pharmacists.

In addition to local service offerings at our brick-and-mortar locations, we’re serving more patients throughout the United States through our mail order service. We offer free FedEx next-day delivery of all fertility medications and supplies to patients served via mail order.

Interested in learning more about how Alto can support your fertility treatment? Request a price quote online or reach out through secure in-app messaging or by phone at 1-800-874-5881.

When Jake Moffatt says he loves building things, he means it — sometimes literally. A construction project manager turned engineer, Jake has spent the past decade building software at mission-driven organizations. Today, as Engineering Manager of Alto Assistant, he leads the team that’s bringing wizard-like support to Alto’s customer-facing app.

Get to know Jake Moffatt, Engineering Manager on the Alto Assistant Team

When Jake Moffatt says he loves building things, he means it — sometimes literally. A construction project manager turned engineer, Jake has spent the past decade building software at mission-driven organizations. Today, as Engineering Manager of Alto Assistant, he leads the team that’s bringing wizard-like support to Alto’s customer-facing app.
Below, Jake chats with fellow engineering manager Mike Riess and recruiter Braden Hanlon about the work ahead for Alto Assistant.

I’d love to learn more about your background to get us started. How did you end up in software engineering?

When I was twelve, I started learning to code in QBASIC because I wanted to make video games. Once I wrote my first program, I was hooked! I loved computers and the creative power they gave to anyone willing to invest the time and energy to learn. Since then, I’ve built games, personal tools and projects, desktop software, and a number of apps and services — I love building things. My career has gone back and forth between construction and software engineering, but it’s been firmly in the software industry for the last ten years or so.

My favorite place to be in a company is working on something new that has a big impact or addresses an important problem. In a previous role, I built an app that helped people find roommates in a city where housing is prohibitively expensive. At that same company, I led the team responsible for creating a new vertical that eventually split off into its own company.

The goal of Alto Assistant is to help customers help themselves before reaching out to support. Our first project is introducing a wizard-like support “assistant” (hence the team name!) that guides the customer through a series of questions to narrow down the area of support. We’ve already identified a few tasks the assistant can help customers complete on their own, including making changes to upcoming deliveries or scheduling new orders.

In cases where we can’t help them just yet, our new tool generates data to help us to learn exactly what customers need help with. It’s a top priority to bake analytics into every new feature we build; even though we have years of experience supporting our customers — and we know intuitively which problems they frequently experience — we don’t have conclusive data to draw upon just yet.

We plan to start with a couple of frequent use cases and measure how often customers reach out to us for support. Then, we’ll chip away at the problem until we’ve seen a substantial improvement in the user experience. From there, we’ll move on to the next biggest problem and repeat the cycle. There’s a reason “Chip away it” is an Alto value: It’s the playbook that we’ve used to automate other critical parts of the pharmacy value stream like intake, billing, and fulfillment.

What opportunities are you most excited about?

Support drives much of the cost of every shipment today, so this is a high-impact area for our business. A year from now, it would be a stellar outcome if the Assistant team could reduce the number of issues that customers need support on by half.

We’re also thinking about the user experience beyond the app. We plan to improve the tooling that our care specialists use to provide support as well. We’ve already discussed some promising ideas like creating the concept of a conversation in support communications rather than an infinite stream of messages and building out enriched communications. We also intend to develop a custom tool that can expedite a customer’s prescription when they need their medication ASAP.

The possibilities are many, and it will take a team of determined, passionate, empathetic people to solve these challenging problems. I’m super excited to see what the Assistant team will do together.

Any lessons learned from previous experience that you’re applying to your role at Alto?

There’s always the temptation to tackle everything at once with new business initiatives. My experience leading new verticals at Apartment List and Snapdocs taught me the importance of being laser-focused on one or two key metrics instead of trying to build out a fully-realized product from the beginning. That’s exactly what we’re doing on the Alto Assistant Team with our clear focus on reducing communications per shipment — how often customers reach out for help because they could not find what they needed in our app.

It’s also important to recognize that we won’t have all the answers right out of the gate! I like to think of product development as a three-step sequence: learning, growth, and maintenance. Alto Assistant is so young that we’re very much still in the learning phase. We maintain a tight iteration loop with everything we ship: launch, measure the impact, and use the results to iterate and refine our hypotheses about what our users want. Our final product could be anything from a customer support wizard to an AI chatbot to a ticketing system — we have to rely on our key metric of communications per shipment, experimentation, and user feedback to shape the direction.

What got you excited to join Alto? What would you pass on to an engineer thinking about applying to the company?

I was impressed by the Altoids I met during the interview process. I knew I would be working with people from whom I could learn a lot, like Elnaz, who started as an individual contributor and went on to become Director of Engineering and, now, Alto’s first Head of Strategy & Operations. I was also impressed by the quality of the interview process itself — a good sign that the company was well-organized internally. Finally, the pitch for the role was extremely clear, with already-established key metrics that would directly contribute to the company’s bottom line and help Alto become more profitable.

For engineers, I think Alto is a great place for both technical challenges and career growth. We’re still small enough that every individual gets exposure to a broad portfolio of high-impact projects. It’s also a great environment for learning about how a business works — the Product & Technology organization does a great job of sharing information and presenting problems in a way that gets to the root business problem we’re trying to solve. There’s a clear line between any project a team is working on and a foundational business metric. Most importantly, we’re a company that makes a truly positive impact on our users’ lives.

Interested in learning more about engineering at Alto? Follow us on LinkedIn.

Redux is great for managing client state: it allows data to be synchronized across the whole app, reduces prop drilling, and makes it easier to understand when state changes occur.

Server state is a different story. Sure, it’s nice to have data available everywhere in our app, which is why we tend to fetch data from the server and dump it into our Redux store. But because our client application doesn't own that server data, it’s hard to know when it has become stale. And what if multiple components trigger calls to fetch the same data? How do you dedupe requests? How do you decide when to refetch?

Why We Switched to React Query for Managing Server State

Redux is great for managing client state: it allows data to be synchronized across the whole app, reduces prop drilling, and makes it easier to understand when state changes occur.

Server state is a different story. Sure, it’s nice to have data available everywhere in our app, which is why we tend to fetch data from the server and dump it into our Redux store. But because our client application doesn't own that server data, it’s hard to know when it has become stale. And what if multiple components trigger calls to fetch the same data? How do you dedupe requests? How do you decide when to refetch?

Below, we’ll dive into how we’re using React Query at Alto to solve these problems and achieve separation of client and server state.

The Old Way: Fetch Server Data and Store It in State

Historically, we would fetch data and set the response in our React component state.

fetchUser(params) {
 this.setState({ isLoading: true });
 
 return getUser(params)
   .then(({ data }) => {
     this.setState({
       isLoading: false,
       user: data.user,
     });
   })
   .catch(() => {
     toaster.toast({ title: 'Something went wrong...' });
     this.setState({ isLoading: false });
   });
}

To make that data accessible from other components, we’d set that data in the global Redux store. This works fine, except that you have to manage your own loading state, the logic for when and when not to make the request, updating the store when mutating data on the server, and knowing when data is stale.

The React Query Way: Fetch and Cache Server Data

With React Query, fetching data and using that data is more declarative.

const { data, error, isLoading } = useQuery(
 // This is our Query Key, which is unique per query so that React
 // Query can manage the cache for us.
 ['user', { userId }],
 
 // This is our Query Function that actually does the data fetching.
 // We can use anything we want: built-in fetch, axios, etc.
 fetchUser({ userId }),
 
 // This query will not execute until the userId exists.
 { enabled: !!userId },
);

Here, we define our query for a user with a Query Key and a Query Function. The Query Key is unique per query, so React Query can manage our cache for us, and if any part of the Query Key changes, the query will automatically fetch new data. In this example, if the user ID changes, the query will fetch new data for that specific user and store that data in the cache.

Naming is hard, but caching is harder. React Query gives us caching of server data out of the box with cache invalidation and request deduping. If we use this same query with the same Query Key in another component, it'll check the cache: if the data is already there, React Query will simply return it, avoiding extra network requests!

Additionally, useQuery runs wherever you use it — no more fetching data when a component mounts. You just use the query and display the data when it’s ready. The cherry on top? The query returns status updates by default, so we don’t need to store isLoading in component state all the time.

Three Optimizations We Get With React Query

When we rebuilt Alto Connect, our web app for healthcare providers, we found impactful benefits in using React Query to help us manage server state instead of using Redux. Alto Connect provides instant access to patient and prescription information and enables messaging with the pharmacy. Because healthcare providers need to quickly switch between patients and clinics, caching data is important to provide a delightfully fast experience. Apart from the cache, what other optimizations do we get by using React Query? Below are a few that helped us.

Once we’ve queried for some data, it gets entered into our cache, so we can utilize that cached data when using the same query in a different component or when fetching new data for a stale query in the background.

React Query is configured with aggressive but sane defaults and considers cached data as stale. Stale queries will always query for new data when the following criteria are met:

The query is optionally configured with a refetch interval

The fetching for new data when the browser window or tab is refocused is especially useful because the healthcare providers using Alto Connect often switch between multiple browser tabs. If there’s an update to a task, status, or message while they’re checking a patient’s medical chart, it will be immediately reflected in the UI when they come back to Alto Connect.

We also set a refetch interval for our queries involving messages. In the old app, we used WebSockets to enable real-time messaging. Although it’s possible to integrate WebSockets with React Query, we opted for a polling solution instead. Because our app isn’t a real-time messaging application, and we don’t need messages to show up immediately, we set a refetch interval on our messages query to poll for new messages every 30 seconds.

const { data, error, isLoading } = useQuery(
 ['user', { userId }, 'messages'],
 fetchMessages({ userId }),
 {
   // This query is disabled from automatically running if we don’t have a userId
   enabled: !!userId,
 
   // Refetch every 30 seconds
   refetchInterval: 30000,
 
   // Continue to refetch while the tab/window is in the background
   refetchIntervalInBackground: true,
 },
);

This is where the enabled option, which disables a query when it evaluates to false, is particularly powerful. We can pause polling for messages if we route to another page and we know that we won’t make any unnecessary requests if there isn’t a valid userId. We don’t have to worry about closing any socket connections or manually clearing an interval.

Most web apps have some sort of navigation menu, and if you already measure or understand your user behavior, you can prefetch data before users even navigate to a different page. Custom hooks makes it easy to expose a function to prefetch data:

export const usePrefetchUsers = () => {
 const queryClient = useQueryClient();
 const prefetchUsers = async () => {
   await queryClient.prefetchQuery(
     ['users'],
     fetchUsers,
   );
 };
 
 return { prefetchUsers };
};

We prefetch queries when users mouseover or hover over a navigation item so that when they navigate to the next page, the data is either actively being fetched or is already in the cache waiting.

We’ve been talking a lot about queries, but what about mutating data? Mutations, in contrast to queries, are imperative. While queries run automatically when we use them, we need to fire a mutation method in order to run mutations. And in order for our user experience to feel snappy, we can optimistically update the cache and then invalidate it after successfully executing the mutation. useMutation gives us some nice side-effect handlers to deal with every stage of the mutation lifecycle. Now when the user sends a message, that new message is immediately reflected in the UI and we keep the data in sync by invalidating the cache and refetching the messages.

With Redux, we needed to build out solutions to each challenge of managing server state. React Query, on the other hand, gives us those tools right out of the box. We no longer need to worry about when to invalidate or fetch new data, making the user experience more predictable — and the developer experience more enjoyable.

To automate a manual, error-prone pharmacy workflow, we turned to event streaming. Here’s what we learned from one of the first Kafka use cases at Alto.

How We Used Kafka to Build an Event-Driven Automation Pipeline and Scale Our Pharmacy

Imagine this: You're at the doctor’s office, and your doctor just wrote you a new prescription. Minutes later, before you even check out with the receptionist, you already have a notification from Alto Pharmacy on your phone that your prescription is ready. All you have to do is pick the date and time that works best for your free courier delivery.

This is the future we’re building at Alto: a future where a prescription can be transcribed, billed, and verified by a pharmacist in five minutes, flat. To get there without dramatically increasing Alto’s head count, we need to automate much of the process, starting with the first step: transcribing, or intaking, a prescription.

As a pharmacy, we receive prescriptions in many different forms. Some are sent electronically, in a structured format, but others are handwritten, phoned in, or even faxed. To represent all of these forms in a single table, we previously required every incoming prescription to be transcribed by an Alto team member, who would answer questions like:

Whom is this prescription for? Is this customer already in our system?

Where did this prescription come from? Who wrote it?

What is the relevant prescription information (medication to dispense, quantity, days supply, directions, etc.)?

This manual process is both time-consuming and prone to human error, which, if uncaught, could impact our ability to process the prescription downstream. Furthermore, at our busiest times, it could take up to two hours for a team member to get through the pending intake queue — unacceptable if we hope to have prescriptions ready to schedule before people even leave their doctor’s office. 

Automating intake required close collaboration between three teams:

Data Science, who built the decision-making algorithms 

Data Engineering, who served up the results of those algorithms

Product Engineering, who used those results to automatically intake prescriptions 

To allow the teams to operate in parallel without toe-stepping — and in the language most suitable for each (the Data Science and Data teams prefer Python, while product engineers work mainly in Ruby) — we separated the code into two environments: 

1. Data Prod Interface (DPI), where the code for generating automation results lives

2. Wunderbar (our proprietary pharmacy operations platform), where the code for requesting and using those automation results lives

The key question: to establish robust communication between these two environments, should we use an API-based approach, or an event-driven one? Each has its pros and cons. 

Legacy approach everyone at Alto is familiar with

Existing enforcement of strong types and data

Difficult to scale with increased data & requests

Requires ongoing authorization / authentication

Infrastructure relevant to other business areas

Automatic retries, reprocessing, and queueing

Our existing infrastructure currently utilizes a hefty API-based structure, so there was a natural tendency to go down this path, but we knew that beginning to migrate services towards an event-based architecture with Kafka at its heart would help us in the long term.

Kafka is a framework implementation developed by LinkedIn, now open-source with the Apache Software Foundation. It aims to provide a unified, high-throughput, and low-latency platform for handling real-time data feeds. 

Alto uses Amazon Web Services as our cloud provider, and luckily, they offer an out-of-the-box managed solution for Kafka, MSK. To configure Kafka with our system, our infrastructure team worked with AWS to set up managed instances to comply with our business requirements. Our Infrastructure team will share more details about this work in an upcoming blog post. 

Kafka offers many benefits. The asynchronous nature of the message system allows for retries, reprocessing, and queueing as well as easy recovery from outages. In addition, the infrastructure work done for setting up the managed cluster would be a one-off workstream. When complete, we’d be able to re-use the same setup and configurations across various business needs to streamline other projects that leverage Kafka. 

Setting up for success: defining a strict contract

One element we had to get right from the start was the data contract. As we send messages between DPI and Wunderbar, we need to ensure messages are produced with the correct schema, so that downstream consumers know what to expect.

Protocol Buffers, or Protos, is an open-source, cross-platform data format used to serialize structured data. Developed by Google, Protos allow you to define how you structure your data once and then use generated code to easily write and read the structured data in a variety of different languages. 

At Alto, we’ve been using Protos for the past few years to speed up development with auto-generated code and ensure data continuity between our Ruby on Rails backend and JavaScript / React / React Native frontend. Protos may seem antithetical to JavaScript and Ruby since they’re both dynamically typed languages, but in practice, they have saved us countless hours of debugging and back-and-forth Slack messages. 

For this project, we turned again to Protos to define the schema for messages produced by DPI and Wunderbar. We defined IntakeAutomationRequest and IntakeAutomationResult messages in Go and generated the types (Sorbet, Flow, etc.), which both DPI and Wunderbar now refer to when producing or consuming messages.

Because Wunderbar is already configured to run on AWS and houses our existing intake logic, it was easy enough to send a prescription to DPI for automation. Where we would normally create a task for an operations team member to manually transcribe the prescription, we instead produce a message to our “request automation” Kafka topic using the ruby-kafka library.

Our consumer, instantiated in an executable that runs on a dedicated worker, consumes messages from a “receive automation” Kafka topic. First, the consumer verifies that a given message corresponds to a prescription we previously sent to DPI. Then, it persists any automation results included in that message. If the automation results are sufficient, we skip intake altogether. Otherwise, we create an intake task to be handled by an operations team member.

Because this project was among our early use cases for Kafka, we wanted to be prepared for the worst-case scenario: we produce a message requesting automation results, and for whatever reason—maybe DPI is down—we don’t hear back. For us, we defined a reasonable time frame as fifteen minutes, in order to avoid building up a large backlog of work that would have to be offloaded back onto our operations team.
To this end, we store metadata about the automation lifecycle in an intake_automation_results table, which includes timestamps representing when we sent a message to DPI and when we received a response back. A cron job runs every minute to check that table for rows where received_at is blank, and sent_at was more than fifteen minutes ago. If this occurs, we flag the prescription to be manually intaken by an operations team member.

Blog

PrEP Drives Decline in New HIV Infections

Tech-Based, High-Touch Patient Engagement at Alto

Alto Pharmacy’s Product Controls for Coupons

Meet the Innovation Team Building Alto's Next Big Bets

How Alto Lowers the Cost of Fertility Treatment Through Better Medication Management

Get to know Jake Moffatt, Engineering Manager on the Alto Assistant Team

Why We Switched to React Query for Managing Server State

How We Used Kafka to Build an Event-Driven Automation Pipeline and Scale Our Pharmacy

Developing Robust Authentication Using Rails, Omniauth, and Okta

Tackling Technical Debt and Improving Security: How Alto Untangled an Overloaded User Model

Considerations and Approaches for Implementing Biometric Login: Part 1

How to Take Action for World AIDS Day 2021

Switch to a better pharmacy.