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

Last month, Alto celebrated the well-deserved promotions of many Altoids across the company. Among those promoted is Elnaz Moshfeghian, who is now Alto’s VP of Strategic Planning & Business Operations. Elnaz shares more about her new role, what she’s most excited about at Alto, and advice she has for those looking to make a career pivot.  

Catching up with Elnaz Moshfeghian, Alto’s new VP of Strategic Planning & Business Operations | Alto

Last month, Alto celebrated the well-deserved promotions of many Altoids across the company. Among those promoted is Elnaz Moshfeghian, who is now Alto’s VP of Strategic Planning & Business Operations.

Elnaz joined Alto in 2016 as a software engineer and when we last connected with her in 2020, she shared her thoughts on building a career in engineering. Since then, Elnaz has pivoted to a truly cross functional, strategy-focused role, where she applies learnings from her engineering experience with her ability to identify opportunities for growth. 

Below, Elnaz shares more about her new role, what she’s most excited about at Alto, and advice she has for those looking to make a career pivot.  

To start, congratulations on your new role! You joined Alto 6.5 years ago, and so much has changed both within the company and the industry at large. Can you tell me a little bit about your journey at Alto? 

I’ve always been attracted to problems that are cross functional and can be solved by bringing together different teams - pharmacists, technicians, logistics, dispatch, sales. I really enjoyed it as an engineer, given that when I joined there were no product managers. We all had to figure out what we were going to build and build it ourselves. I loved working with teams, which is why I pursued the manager track. I noticed pretty quickly that the most interesting and challenging problems rarely came down to technical decisions, but more-so to people and priorities. 

As I grew in my engineering career, and got to lead teams solving problems, I was always searching for how to expand my understanding and impact across the business. I had the opportunity to shift into a strategy and operations role, which allowed me to shadow the CEO and learn a great deal while also identifying the company’s key priorities, understanding how they're doing, and ensuring that they stay on track. The new role allows me to use everything I’ve learned over the last 6.5 years at the company while at the same time, learning a lot from a seasoned leader like Alicia on how to run a business. 

Your previous experience was in engineering, and you didn’t work in healthcare or pharma before joining Alto. What has been the biggest surprise to you since joining the company? 

There are a lot of different hands in healthcare; it's a really complex space and there’s a lot at stake. I’m always mystified by how hard it is to align different parties’ incentives to result in the right outcome for patients. It underscores the importance of Alto’s mission: to fulfill medicine’s true purpose — to improve quality of life — for everyone who needs it.

Tell me a little bit about your current role. What are you most excited by? 

I’ve loved seeing how the different pieces of the company connect, and being able to connect the dots when we’re missing something. It’s been really fun to see how a little bit of communication and collaboration can go a long way. I also love thinking about how what we’re doing today could set us up for bigger things in the future, and how we build today in a way that opens a lot of doors for us down the line. 

In your opinion, what are the biggest opportunities for the company? 

There’s always an opportunity to be excellent at the basics. Are we consistently providing the best patient experience? Are we getting patients the best price? Are we saving time for prescribers and their offices? Those are problems that we’ve been solving for a long time, but it just gets more interesting and challenging as we’ve gone into new markets and therapeutic areas, and worked with different kinds of patients and prescribers than we used to. 

Something that I’ve always been intrigued by is - how do you bring more transparency around pricing to prescribers and patients at the earliest possible time, so that they can make the best decisions? It’s something that’s really missing in the industry. It’s not easy to do, and that’s definitely something I think a lot about - ‘How can we be the one who makes it easy for prescribers to know what they’re about to send to the patient, and for the patient to know what their other options are?’ Because a lot of times, what your insurance may cover and what your doctor may prescribe may not always be the best option. There might be other options, and I think a lot of people don’t know to ask about that. 

What are the biggest challenges in the pharmaceutical industry today? 

I think there’s been a lot of great activity from different patient advocacy groups and state governments to regulate the worst of what’s happened in healthcare. It’s been cool to see that take shape over the last five years. The challenge is that it’s very hard to write legislation and force some of these things, and so I’ve honestly gotten more interested in how do you write the right laws and approach regulation in a way that allows innovation to still happen and thrive, and still protects the patient at the end of the day. 

Back to your engineering roots – what advice do you have for young engineers?

Given the state of venture capital and the industry, a lot of engineers are going to earlier-stage companies, because there’s a little bit more investment and activity happening. I had to figure that out along the way - how do you operate as the third engineer on the team? Being anyone in an early-stage, small company - and an engineer especially - comes with its own unique challenges and skills. It’s not something there’s a ton of resources around. There’s a lot of resources about how to start a company, but not a lot for how engineers can grow their career at a company at that stage. So, my advice would be to seek out mentorship and cross functional peers from whom you can learn and grow. 

You pivoted from engineering to operations and strategy. What advice do you have for someone looking to make a career change? 

As an engineer, I’ve really focused on making an impact, whether that’s through building a product or shaping the business with what I know, with tech being the backbone. And I think that’s something we don’t talk about as much in engineering - how do you take your skills and really channel them for maximum impact and better understanding of a business? And for people who want to start their own companies someday, taking the path I did could be really valuable. It allows you to be a better entrepreneur and a better contributor if you can see the connection between engineering choices and the systems you’re building, and how they impact your customer and other parties. 

The other piece is being comfortable with wearing a lot of different hats. It’s what really helped my growth, and it’s counter to a lot of advice you get. People will tell you to go deep, get specialized and go down one path. You need to, to some extent; I absolutely had to figure out how to be a better engineer and a better leader. But the most growth for me wasn’t necessarily to stay in engineering – it was to take a turn. Hopefully, I can give colleagues a little more confidence who want to take a turn and increase their impact, growth and learning. 

Catching up with Elnaz Moshfeghian, Alto’s new VP of Strategic Planning & Business Operations 

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.

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.

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.

No industry is immune to burnout, including pharmacy. At many traditional retail pharmacies, individual pharmacists are often asked to do more than is possible on any given workday. Not only does this deprive talented and extensively trained health professionals of a manageable working environment, it deprives patients of the exceptional care they deserve.

pharmacists-spotlight-roni-hein

The better pharmacy model we’ve created at Alto makes life easier for everyone involved in the prescription process: patients, physicians, and pharmacists. And in restructuring how pharmacists work, we haven’t just separated fulfillment and patient care responsibilities into different roles — we’ve ensured that there’s ample support for each specialization, as there should be in any profession.

To wrap up our series of pharmacist profiles in celebration of American Pharmacist Month, we spoke to Roni Hein, a patient care pharmacist lead who takes care of her team so that they can in turn care for patients.

What motivated you to pursue a career in pharmacy?

It all began with my high school and college job at Target. I interacted a lot with the pharmacy team while working in the health and beauty section and eventually moved into that department.

I never expected it to be more than a college job, but it turned into the beginning of my professional path. As I worked there, I was able to see the impact pharmacists made in customers’ lives each day. It really struck me that in many communities, including mine, pharmacists were the most accessible healthcare providers. That accessibility is so impactful on a person’s well-being.

What challenges have you encountered as a pharmacist?

Limited time and isolation behind the counter, without question. In retail pharmacy, more and more responsibilities were added to my job description, with fewer resources to accomplish them.

All pharmacists value the personal connections we make with patients. I think many of us would say that making an impact through patient counseling is the best part of our day, but that is often what gets lost when pharmacists are asked to do more. Our primary driver for entering the profession is the first thing to go. I found a very refreshing change at Alto.

Everyone at Alto, no matter their department or role, has the same shared goal of improving patient lives by transforming the pharmacy model. As a patient care pharmacist lead, I do that by supporting my people. I create the space for our pharmacists to do their best work. They are able to have better interactions with patients because they are taken care of.

The pandemic has been a trying time for many companies and teams, including mine. I am constantly looking for new ways to ward off burnout and maintain a sense of camaraderie, not only for the pharmacists I manage, but for the benefit of our customers as well.

The individual locations of many retail pharmacies can feel very separate from each other. Each one often serves a single population.

The centralization of Alto’s patient care team is a contrast to that model. We have a cohesive, unified team serving all patients. That means there’s a depth of resources available to each pharmacist, which is also really important for retaining great talent.

Our pharmacists have a great support system in their colleagues. There’s other smart, driven pharmacists to bounce ideas off of. Unfortunately, you don’t always get that in our profession.

It also means that you don’t have to worry about anything falling through the cracks if something comes up outside of work. It's a game changer to be able to take time to grieve a loved one or to care for your child if they’re sick while knowing that your patients are still in expert hands. I never had that in retail pharmacy.

Finally, what is one thing people would be surprised to know about life as a pharmacist?

At a tech-oriented pharmacy like Alto where there’s so much innovation, you’re constantly thinking of new and creative ways to problem solve. It’s challenging in the best possible way. There isn’t a day when I don’t have to put my critical thinking skills to use.

This is part of a series of pharmacist profiles to recognize American Pharmacist Month 2022. Meet the other pharmacists featured in this series: patient care pharmacist Travis Allison, specialty patient care pharmacist Gabrielle Kaplan, and medication therapy management pharmacist Wei-Lin Chang.

National Pharmacists Month Spotlight: Roni Hein

Pharmacists are one of the most accessible healthcare professionals, seeing people 5 to 8 times more frequently per year than primary care providers. Their role has become more expansive than ever, and many people don’t realize just how integral they are to a patient’s health and well-being.

National Pharmacists Month Spotlight: Travis Allison

At Alto, fulfillment pharmacists focus on dispensing medication — ensuring that the entire process is carefully monitored every step of the way — while patient advocacy pharmacists tackle anything related to a patient’s wellness, from provider communication and insurance coordination to guidance on managing chronic health conditions.

These specializations have opened up entirely new possibilities for the patient-pharmacist relationship at Alto. And this October, as we celebrate American Pharmacist Month, we’re spotlighting a few of the extraordinary Alto pharmacists who focus on patient advocacy.

To kick things off, we’re pleased to introduce Travis Allison, a patient care pharmacist based in Dallas, Texas.

I took the long and winding road here. I didn’t always know this was what I wanted to do. In college, I started off as an English major but had a change of heart after a semester or two. I went on to study agriculture, and those experiences made me believe that I could pursue a path grounded in science.

My childhood memories of visiting the pharmacist were always in the back of my mind. As a kid, I hated going to the doctor. When those dreaded appointments were over and done with, I knew I’d get to see a guy in a white coat who would give me something to feel better. I always saw pharmacists as a comfort in the often scary world of healthcare.

At any chain pharmacy — which is where I spent my career before Alto — pharmacists are inundated with so many tasks. It isn’t that these tasks are unrelated to pharmacy, but they interfere with our ability to deliver patient care.

On a typical day, I would give 100 Covid shots and fill 200 prescriptions by myself while also coordinating billing and calling doctors’ offices. We also had to think about corporate metrics. I was frequently asked to get more people signed up for text message alerts and hit specific quotas.

Patient care is always the priority, for any pharmacist, but the reality of my job made it extremely difficult, and often impossible, to give patients the time they deserved.

The first thing I noticed when I started at Alto were the specializations. We have many different team members to handle all the responsibilities that fall on a single person’s shoulders at a traditional retail pharmacy.

I’m a patient care pharmacist, which is distinct from fulfillment pharmacists who process prescriptions.

I review prescriptions for accuracy and initiate medication transfers, and I interact with both patients and doctors. I’m here to answer any questions a patient has about their medication.

In a way, I feel like I’m on the frontlines the same way that I was when I worked in a pharmacy chain. It’s all of what I liked about retail pharmacy without the distractions of retail. We’re able to practice our most important functions as pharmacists without the noise.

We’re utilizing technology in a way no other pharmacy does, which allows us to communicate with patients and providers in so many different ways — without having to rush through interactions.

And the wheels of change turn much more quickly at a tech-oriented company than they do at a massive corporation. At my previous job, you could have conversations all day about what improvements were needed, but nothing ever happened. Alto was founded by software engineers, and we’re able to easily make changes in real time.

As a digital pharmacy, we serve so many patients that only we can serve. I talk to many who are homebound without a caretaker. Because of Alto’s model, I’m able to communicate with them, and we’re often their only point of contact within the healthcare system. I don’t know of another way these patients could get pharmacy care.

The digital model also allows us to get a broader view of healthcare, and to make an impact on a larger scale. Alto was one of few places where New Yorkers could get the Covid medication Paxlovid when it was first introduced.

It was incredible to be sitting here in Texas, getting prescriptions out in New York City just as a new variant came out that was really devastating to the city. At no other pharmacy would I have been able to help out my neighbors in New York.

Those moments where you can tell in a patient’s voice that you seriously helped them. To me, that’s an indication of how well I’m doing my job, much more so than the number of prescriptions processed or dollars generated.

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.

Last year, we set out to tackle this technical debt by splitting the User model into separate concerns and refactoring the entire system into this new paradigm.

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

At Alto, we have three types of users: customers, healthcare providers (nurses, doctors, etc), and operations users who run the pharmacy. For each type of user, we maintain a separate application (though they share a monolithic backend for now): our customer app; our Alto Connect app for providers; and our internal pharmacy management tool called Wunderbar, which powers the pharmacy experience from prescription intake to fulfillment.

Early on, we made the pragmatic choice to represent both customers and operations users with a single User model, distinguishing them with a “roles” attribute. This required repetitive checks that, over time, slowed down our engineering teams, presented substantial privacy risk, and posed difficult scaling challenges as we evolved our monolith into different microservices. 

The challenges of relying on a single User model for different types of users

The notion of a User is core to our concept of identity from which authentication and authorization proceeds. From a security perspective, it’s difficult to build an extensible and clean authentication and authorization system when you’re overloading one model for two very different populations of users. From a privacy perspective, this muddied customer records (which are subject to more restrictions because they’re healthcare records) with workforce records, hamstringing many analytics efforts.

Authentication: Alto employees who were also Alto customers were required to use their work emails for their customer accounts. Not only was this restriction frustrating for Alto employees, but it also posed a security risk: employees should only be able to access Wunderbar via corporate SSO, not their personal account passwords. 

Authorization: Engineering new authorization capabilities required intricate knowledge of the idiosyncrasies of our user structure. This both slowed down development and created tremendous risk that any mistake could easily escalate user permissions.

Privacy: Because they existed in the same table, both customer records and Alto operations user records were classified as Protected Health Information, or PHI, which severely limited what we were able to do with them.

Attribution: Our robust audit logs were significantly less useful when a user ID in the transaction log might refer to either an ops user or a customer.

State management: Some updates pertaining to admin identity lived on the customer model, some lived on the employee model, and others lived in other various models.

Architecture: Tight coupling would have prevented us from decoupling our monolithic system into smaller services.

Our backend is primarily a monorepo Rails application that shares a tremendous amount of functionality between our customer, provider, and ops user-specific domains. Generally we use JWTs to secure customer and ops user sessions. These JWTs are issued only once valid credentials have been present.

Ops users are required to log in via Okta SSO, enforcing both valid username/password as well as a two-factor authentication (2FA) prompt. We use Devise and Omniauth to wire up the OIDC flow with our upstream identity provider, and we use CanCan to expand a set of roles per-user into a set of capabilities that restrict what resources they can access/modify.

Ops users primarily work in our internal pharmacy management app. However, the state of these users was shared between several different tables: Users, which otherwise refer to customers, and Employees, which share some ops user-specific state tied to Users.

Large change sets of code being deployed at once are harder to code review, harder to unwind if something goes wrong, and are more likely to be more disruptive. For this project, we knew that such a large architectural change had to be broken up into many more-digestible pieces if we were to be successful. The plan:

1. Create a new dedicated model for our ops users

# == Schema Information
#
# Table name: wunderbar_users
#
#  id                        :bigint(8)        not null, primary key
#  user_id                   :bigint(8)        indexed
#  email                     :string           not null, indexed
#  first_name                :string           not null
#  last_name                 :string           not null
#  token_last_invalidated_at :datetime
#  roles_mask                :integer          default(0), not null
#  title                     :string           not null
#  team                      :string           not null, indexed
#  is_active                 :boolean          default(TRUE), not null
#  slack_user_id             :string
#  pod                       :string

This was the easy part: create the database structure for a properly isolated admin user type, which we called a WunderbarUser.

We now had our admin user state split between Employees and Users, with a new table that engineers and analysts wanted to use that was not yet populated, and we had to make progress while allowing new hires and new customers alike to onboard to our platform.

2. Synchronize state between the old tables and new table

Next, we created a WunderbarUser for any User who was, or ever had been, a Wunderbar user. This required some historical digging —we had a lot of people who were onboarded, and even some offboarded, before we even had the intermediate Employee record!

Two major choices at this stage really helped the project succeed. First, we ensured that the WunderbarUser records all had IDs matching the corresponding User records. This is because a lot of our legacy audit records (that we’re required to preserve and keep useful as a Covered Entity under HIPAA) referenced an `admin_user_id` column populated with the ID of the User. If we just created all new entries for WunderbarUsers, these old logs would require at least one level of indirection (e.g. querying back to User) to make useful.

     # Create with the same ID as the user that we're creating this from.
     wunderbar_user_attributes = {
       id: user.id,
       user_id: user.id,
       email: user.email,
       roles_mask: user.roles_mask,
       date_of_birth: user.date_of_birth,
       token_last_invalidated_at: user.token_last_invalidated_at,
       first_name: user.first_name,
       last_name: user.last_name,
       preferred_first_name: user.preferred_first_name,
       is_active: false,
     }

Second, we created a new WunderbarUser any time we created a new Employee record (e.g. when we onboarded a new employee) and synchronized any changes between Users, Employees, and WunderbarUsers tables. As a side note: we knew we’d have to protect this syncing logic to ensure that we only copied each change once — otherwise, our callbacks would fire forever!

3. Migrate functionality slowly to use the new ops user model

We migrated logic to reference WunderbarUsers where previously we’d referenced Users and/or Employees. Authentication, authorization, audit logs, and pharmacist licenses were all updated here — albeit painstakingly!

We then migrated all of the foreign keys our various Postgres database tables held to either the Users or Employees tables to instead reference the WunderbarUsers. This ended up being around a hundred foreign keys, but a constraint-only migration that fortunately didn’t involve any data changes.

In short: our goal was to do this change slowly and steadily enough that nobody would notice until, one day, we could announce to the team, “Hey, we did a big security-pertinent project, and now you can change your customer email to be anything.”

Authentication: While we use the same JWT format for each, our customer and operations user authentication systems are now totally separated.

Authorization: With separate user types, we have separate capabilities and domain-specific authorization checks for each area, enforced in code.

Experience: Onboarding as a new Altoid (somebody who works here; come join us!) is totally separate from the customer experience, and you no longer need to link your accounts together.

Privacy: Our ops users who choose to be customers enjoy the full privacy afforded to our customers without tying their account to their work identity in any way.

Attribution: Legacy audit logs are still index-able and query-able with the same IDs, just in a slightly different table.

State management: Customer state lives on the User table, and ops user state lives on the new WunderbarUsers table. Our callbacks on each have been dramatically pared down, and our intermediary Employee table is entirely gone, along with a number of other now-ancillary tables.

Architecture: We have a clear path to federate RBAC checks without shipping our entire customer database between services.

Bonus: Performance and code readability generally improved by removing complex joins and join tables and isolating concerns between the customer and ops user domains.

Another Bonus: Significant refactorings and increased test coverage along the way while we cleaned up some very old, very stale code.

Large architectural changes of legacy systems with heavy use are rarely 100% smooth. Here are a few learnings to keep in mind the next time you tackle a hefty piece of technical debt. 

1. Always validate your assumptions (e.g. the data your constraints are against) when foreign keys are concerned. Multiple times we assumed, “Hey, we’ve migrated a bunch of really big tables that are really old (insurance claims, prescriptions, and more), so there’s no way we could have another admin user that we haven’t created a commensurate WunderbarUser for, right?” Wrong! Your data can always have inconsistencies, but a simple SQL query (e.g. validate that all values of the column you’re migrating the foreign key to have a matching WunderbarUser) can save a lot of time and headaches.

2. When migrating foreign key constraints on tables with active reads in Postgres, ensure you break it into two steps. Migrate your foreign key with `{ validate: false }`

 def up
   remove_foreign_key :inventory_orders, to_table: :users, column: :created_by_id
   add_foreign_key :inventory_orders, :wunderbar_users, column: :created_by_id, validate: false
 
   validate_constraint
 end

Validate the named constraint of your foreign key separately

 def validate_constraint
   validate_constraint_statement = 'ALTER TABLE "inventory_orders" VALIDATE CONSTRAINT "fk_rails_abcd1234";'
   ActiveRecord::Base.connection.execute(validate_constraint_statement)
 end

3. When working with legacy tables, be mindful of legacy systems. Our Billing service used a very outdated golang ORM that panicked if a column specified by the `struct` in source no longer existed; this caused a late-night outage that made auto billing requests back up the next day.

4. Scoping projects is hard! This was a larger project than our team had ever scoped and delivered before. Once all the dust settled, this project took several months longer than our initial scoping estimates.This project was worth doing, but better estimates allow us to prioritize better. If we’d had a great scope of this immense project upfront, would we have chosen to do it first? Also, this was a tremendously difficult project to separate into material stages; all the benefit was really backloaded.

In the end, this was a very satisfying and important project to complete. We wouldn’t have been able to accomplish it without a lot of help from our colleagues on the Platform team, the Security team, and across many other functions atAlto. Very large projects that involve a lot of moving pieces and impact other teams are always scary — but we can’t let that fear prevent us from making the changes we know we need to do in order to be successful long-term.

The Engineering Team is hiring! Learn more about open positions here.

In our previous post, we discussed how we designed our biometric authentication system with both privacy and a better user experience in mind. In this post, we'll show you exactly how we did it.

Considerations and Approaches for Implementing Biometric Login: Part 2

In Part 1, we discussed how we designed our biometric authentication system with both privacy and a better user experience in mind. In this post, we'll show you exactly how we did it.

To build a new authentication mechanism, we opted to use the react-native-biometrics library. This library interfaces with the device's biometrics, generates a keypair, and stores the private key within the device's keystore. When logging in with biometrics, the library creates a signature using the stored private key, and the signature is then sent to the server for validation. (Note: this library is now unmaintained. At the time of writing, this implementation can instead be accomplished with the following maintained libraries: expo-local-authentication to access device biometrics, keypair to generate a keypair, react-native-keychain to access the device keystore.)

Check if biometrics are supported and configured by the user for this device.

const { available } = await ReactNativeBiometrics.isSensorAvailable();

If yes, prompt the user for a biometric scan.

const { success } = await ReactNativeBiometrics.simplePrompt({ promptMessage: 'Confirm ID' });

If the scan succeeds, generate a keypair. The react-native-biometrics library's createKeys method will automatically save the private key to the device's keystore, and return the public key counterpart. Send the public key to your server.

const { publicKey } = ReactNativeBiometrics.createKeys('Confirm biometrics');

// Save the public key to your database
post('/save_biometric_key', { key: publicKey, device_id: 'xyz' })

When the user tries to login with biometrics, scan their biometrics. This time, if the scan succeeds, create a signature using the stored private key. The react-native-biometrics library's createSignature method handles all of this.

// Prompts for scan
// On scan success, accesses private key and uses it to generate a signature, which is then returned
const signatureResponse = ReactNativeBiometrics.createSignature({
  promptMessage: 'Face or fingerprint ID for Alto Pharmacy',
  payload: BIOMETRIC_SIGNATURE_PAYLOAD,
});

Send the signature to the server to validate against the public key. If validation succeeds, the user has successfully authenticated with biometrics and can proceed into the app.

// Call your server API to validate the signature against the public key that you've stored in the database
const validationSuccess = await post(
  `/validate_biometric_signature`,
  {
    signature: signatureResponse.signature,
    payload: BIOMETRIC_SIGNATURE_PAYLOAD,
		device_id: 'xyz',
  },
);

if (validationSuccess) {
  // Login Success
} else {
  // Login failure
}

import ReactNativeBiometrics from 'react-native-biometrics';

const setUpBiometricLogin = async () => {
  // Check if biometrics are supported and configured on this device
  const { available } = await ReactNativeBiometrics.isSensorAvailable();

  if (available) {
    // Prompt user to scan biometrics
    const { success } = await ReactNativeBiometrics.simplePrompt({ promptMessage: 'Confirm ID' });
      
    if (success) {
      // If scan is successful, generate a keypair, then save the public key to the server
      const { publicKey } = await ReactNativeBiometrics.createKeys('Confirm biometrics');

      post('/save_biometric_key', { key: publicKey, device_id: 'xyz' })
    }
  }
}

const loginWithBiometrics = async () => {
  // Scan user's biometrics. On scan success, generate a signature
  const signatureResponse = await ReactNativeBiometrics.createSignature({
    promptMessage: 'Face or fingerprint ID for Alto Pharmacy',
    payload: BIOMETRIC_SIGNATURE_PAYLOAD,
  });

  // Validate the signature against the public key saved on the server
  const validationSuccess = await post(
    `/validate_biometric_signature`, 
    {
      signature: signatureResponse.signature,
      payload: BIOMETRIC_SIGNATURE_PAYLOAD,
      device_id: 'xyz',
    },
  );

  if (validationSuccess) {
    // Login Success
  } else {
    // Login failure
  }
}

Blog

Catching up with Elnaz Moshfeghian, Alto’s new VP of Strategic Planning & Business Operations

Tech-Based, High-Touch Patient Engagement at Alto

Alto Pharmacy’s Product Controls for Coupons

National Pharmacists Month Spotlight: Roni Hein

National Pharmacists Month Spotlight: Travis Allison

Why We Switched to React Query for Managing Server State

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

Considerations and Approaches for Implementing Biometric Login: Part 2

Introducing Alto Connect

How Alto Reduced Time to Resolution for Production Incidents

The Next Evolution of Our Company Values

Get to Know the Team That Has Doctors Calling Alto “The Pharmacy of The Future”

Switch to a better pharmacy.