Robinhood moved its UI to the server and shipped in days instead of weeks
One button sat left-aligned on iOS and centred on Android, simply because two engineers built the same design at different times. Multiply that across three thick clients and app store reviews, and a basic feature takes months. Robinhood engineering manager Akanksha Gupta shows how her team handed rendering to the server, and asks when that power stops being worth its cost.
See how SDUI works, a sample response, its trade-offs and how Robinhood adopted it
Akanksha Gupta, Engineering Manager at Robinhood, explains how server-driven UI (SDUI) moves rendering logic from iOS, Android and web clients to the server so teams can ship and experiment faster. She walks through a sample response, weighs the advantages against real challenges such as testing and performance, and shares how her team moved Robinhood's ETF pages and charts to SDUI.
“The biggest thing here is that even once this is done, we are really at the mercy of our customers to go ahead and update their app version so that they can make use of the latest features.”
“So, in the market, and personally, we've gone from like weeks to literally, you know, matter of days, like as soon as you have the change in, and your server deployments can be controlled through internal approval process.”
What you will learn
Explain how server-driven UI differs from traditional client-rendered mobile development.
Read a server-driven UI response that combines a data model with a view model.
Weigh the gains of SDUI (shared logic, shorter releases, A/B testing, faster incident response) against its costs.
Anticipate SDUI challenges such as nesting depth, testing risk and large response payloads.
Plan an incremental migration to SDUI and build a business case from the product backlog.
Key takeaways from the speaker
How do we iterate and ship products faster to our customers using server Driven UI
How is server driven UI different from our conventional engineering
What are the pros and cons, is it a one size fits all solution?
Robinhood's engineering team journey to Server driven UI(charts)
Details
Level
Beginner
Format
Talk
Technical depth
Practitioner
For
Early career, Mid-career, Senior individual contributor
Length
19:20
Published
July 2022
Questions this talk answers
What is server-driven UI?
The server returns both the data model (what to display) and the view model (how to display it), so the client becomes a rendering slate with very little logic of its own.
Why is traditional mobile development slow to iterate?
Each platform implements the UI separately, every release goes through App Store or Play Store review, and users must update their app before seeing changes. Bad releases are also hard to roll back.
What are the main challenges of server-driven UI?
The client has no UI context, so interactions and logging must be built into the framework, and teams must choose sensible backend abstractions and nesting depth. Testing becomes riskier and large responses need load testing for performance.
When is server-driven UI not worth adopting?
For a very small, basic app with mostly static data, SDUI might be over-engineering, so teams should weigh the pros and cons for their stage.
How did Robinhood migrate to SDUI and sell it to the business?
The migration took several months in milestones, moving static data first and charts as a fast follow-up. The team sold it with a one-pager showing backlog items scoped at weeks that could ship in a day or two.
About this talk
How do we ship faster and better products to our customers?
In the traditional software development, the data is driven by a backend service while the load of UI resides on the clients. As we scale, all our clients (IOS, Web, Android) end up with custom logic residing at client side. This can cause logic to diverge across platforms. Further, things become ugly if there is a new bug or feature needed as the app needs to follow a full release cycle on App Store. This often takes weeks to get the changes out to production in customer’s hand. Next, we are at the mercy of our customers to update the app version to be able to use the latest features. This slows us down with both iteration and experimentations.
In this fast-paced world where technology is changing every minute, do want to wait this long?
Enters Server driven UI where the server drives the UI. The data and UI is sent from the server to UI that simply acts as a rendering slate with no/little logic of its own. This opens a plethora of opportunities for companies to be agile and build faster to ship awesome products to their customers.
In this talk, we will introduce server driven UI to the audience, its pros and cons and share my engineering team’s personal journey from conventional to server driven UI development.
Power comes with responsibility: when SDUI is overkill (50 s)
How to sell server-driven UI to the business (59 s)
Thank you, everybody, for joining this session on rapid iterations with server-driven UI. So, first of all, I would like to ask you, you know, what would you do if you were in my shoes? So, let me share the story. I joined my current team at Robinhood that owns critical features around the stock detail pages, the Robinhood charts, and the shareholder experience.
Soon after joining the team, I found out that all the three clients that we support, like iOS, Android, and web, are super thick. What that means is that the majority of the rendering logic was on. So, when one of my first projects that came into my queue, the estimation of getting the work done across all the platforms was super huge. You know, when I got into the room with my engineers, and it was like, yes, it's going to take us a few X months to kind of deliver this basic thing. Also, on top of it was added difficulty of inconsistencies across the three platforms. So, a very basic example is, let's say we had a button on our iOS app.
It was left aligned, but on the Android app, it was center aligned. You might want to know why? Because there were two different engineers at two different times implementing, you know, the similar design of the app. And so, this caused a lot of, like, divergent behavior that accrued over time. So, I'm Akanksha Gupta, an engineering manager with Robinhood. And today, I would like to share our journey on rapid iterations with server-driven UI. Since we are all virtual here, with a show of maybe e-hands through chat, how many of you have heard about server-driven UI in one form or the another? Anyone here? Awesome. Thank you so much. Yeah, that's perfect. So, we do have few folks who've, you know, heard about server-driven UI. Awesome. So, let's just jump into it. So,
by the next 15 minutes, where we are going to talk about traditional mobile development, you know, what exactly is this, you know, server-driven UI, how it works. We'll go through a very basic, you know, sample response just to, you know, visually understand the concept, talking about advantages, challenges, and I want to, you know, make sure I leave you all with some key takeaways. So, yeah, let's dive into it. So, first, I want to talk about how a traditional mobile development looks like. So, we'll have our client developer who would create the layout and presentation of the UI. Once the code is written, it is packaged into the app and is submitted to Play Store if it's Android or App Store if it's iOS. Next step would be that, you know, the companies like Apple or Google
will kind of review our app version and, you know, once we get a greenlit, they are made available for our users to install. The biggest thing here is that even once this is done, we are really at the mercy of our customers to go ahead and update their app version so that they can make use of the latest features. See, there are a lot of hurdles, you know, really to get your code out there.
This definitely slows us down, you know, in this fast-paced world, especially when we want to try a lot of, like, iterations and, you know, experimentations to find out the right behavior for our customers. Another thing that strikes to my mind is this seems to be more of like a static form of development. One thing from my experience is that if there is like a high severity issue or a trouble ticket from a customer, you cannot easily roll back these app versions. So, you might want to, like, push another code change and, you know, kind of have to go through this process. So, divergent behavior, inconsistencies across your platforms and super slow pace, you know, when you are thinking about these product launches. So, let's take a moment and look at the diagram. We have the client who is
sending a request to the server. The server will respond back with the data. So, what needs to be rendered? But the UI or the presentation is really packaged into our client app itself. So, how does this look visually? So, let's say we have our three platforms, web, iOS and Android. We have the way, let's say we have two screens for our app. And as you can see, all in itself is like, you know, huge chunks of code that needs to be maintained for all three platforms.
And as I said that, you know, in this really fast-paced world, you know, where technology is changing every minute. Do we really want to wait this long? I hope not, right? So, here enters the server-driven UI. So, let's try to understand, you know, what exactly is server-driven UI. So, in this case, the server will drive how our presentation or the UI looks like. So, let's just, you know, walk through the basic, you know, example here. The client will send the request to the server and instead of the server just responding back with the data, it's going to tell us, it's also going to provide us the data model plus the view model. So, what we are trying to do here is tell me what needs
to be displayed, but also tell me how it needs to be displayed. The big advantage of this approach is that you are offloading a lot of your logic from the client to the backend. So, then you have less less dependency on your client. Let's say if you want to like, of course, in this particular scenario, your client literally becomes like a blank rendering slate with very little logic of its own. So, what does it do? It opens up a plethora of opportunities for companies to be really agile and, you know, move faster to ship awesome products. So, let's dive a little into, you know, how this looks visually.
So, again, we have our three platforms, web, iOS, and Android. And as you can see, we have, you know, the two screens can be powered from like a single source of truth. So, there is like central logic that exists at the server side that can power all the three platforms. And if, let's say, we have to make a simple change, you can go ahead, change the API server response, and boom, you know, it's going to render across all three platforms. So, how does it work? You know, just like going through a little more, you know, details one step forward, you know, the client sends a request to the server, the server will send back a view and a data model, maybe using an API call. One of the common
forms, and I know, you know, a lot of big companies use is the JSON format. But you can also use, you know, other formats, let's say XML and all. Now, once we have this response from the server, the client needs to be smart enough to like parse this, you know, view and model separately. So, as I said, views will determine, you know, how we want to show our presentation layer, and the data model will determine, you know, what needs to be rendered.
Now, take a pause and think about that we do want our end customer to do some actions, right? So, some sort of, let's say there's a button, you know, the customer clicks on the button, and there is some sort of, you know, interactivity involved. So, these sort of like triggers and actions need to be predefined at the client side. So, let me take a very basic example. Suppose we want to build a client component, which should understand, you know, how to render a button on the server, when given a server response. This means you can actually set up a button, anywhere on your app, without any client side change. This also means that you can actually remove that particular button from your app.
So, you really don't have to go through that whole deployments, you know, mobile deployment cycle. And common UI items, let's say, you know, label or button or, you know, like some carousals, can all be templatized using this. So, you know, definitely want to refer like the Lord of Rings, like, you know, one code base to kind of rule them all.
So, let's look at a very basic, you know, sample response. This doesn't mean that this is how we implement at Robinhood. This is just to, you know, help us all understand the concept. So, let's say we are trying to, you know, render fruits on our app. With Apple, you know, 20% people like it. Banana, 25%. So, that's like the likability factor. So, in an SDUI system, it would look something like what we see on the right. So, the type would be home screen. So, we are trying to render a home screen, where the title should display as fruits. And then, we have the fruit sections, which contains a sorted list of, you know, UI elements that need to be rendered.
So, the first one says, hey, the data model should be that the label should say Apple with likability percentage 20% with some description. Now, how should it be rendered? It should be of the type button. So, you know, build a button that says Apple. The color should be red, and the height and width should be 20 and 50.
You know, the other list item is label is banana, you know, with the percentage and description, and we want to display it more of as a header text with yellow color. So, as you can see, in a single response, we know what is to be rendered, and how it needs to be rendered. And so, the API is returning a collection of all these different UI components that make the whole presentation of our screen. Now, what are the advantages of this approach? First and foremost, you know, that jumps up is, you know, you write once, and you share the business logic across multiple platforms, right? So, brings in a big factor of reusability in our overall, you know, design.
Since you are, you know, you are able to make your UI changes. So, as I discussed, you can add button, remove button, you know, with the change at one central place, there is so much power in your hand, right? Shorter release cycles, right? You are no more dependent on, you know, Apple and Google to kind of, you know, review your model, you know, then our customers to update the app version to make use of it.
So, in the market, and personally, we've gone from like weeks to literally, you know, matter of days, like as soon as you have the change in, and your server deployments can be controlled through internal approval process. So, you can really move fast. You can do a lot of like A/B testing with this sort of power, you don't have to, again, you know, go through the whole process. One big thing that it helped me and my team was eliminating like the divergent behavior that we had across platforms.
So, now if you go and look at our iOS, Android, and, you know, web app, they are pretty much, you know, consistent in terms of the data and the charts that show up. It also helps our client keep super thin. So, you know, majority of rendering logic is now on our server side. So, we don't, we have very less dependency on our client platforms.
One key call out I want to make is that in times of like a high severity issue, this has really helped us because we can have a faster, you know, MTTR or like mean time to response for, you know, remediating high severity issues. So, this has really helped us, you know, with such sort of scenarios. So, since nothing comes for free, it also has its own challenges. So, the first and foremost is, you know, it's a pros and cons of both on both sides. So, client has no context on the UI.
So, it kind of becomes as this blank rendering slate. So, your system, the design that you make should be smart enough to have, let's say, the client interactions, logging, et cetera, defined as part of your framework. The second biggest challenge is building the right backend abstractions, right? For example, as we saw in the JSON code piece, we had, you know, like a lot of nesting there.
So, what level of nesting is okay? And, you know, that fine line is definitely missing, right? So, it's more think about it more like a recursion, like you can go as deep as you want, but you do want to have a boundary somewhere. Testing can be challenging sometimes, because you have so much power, you know, as, you know, with making changes to your server, you want to make sure you're not breaking any of the UI, right? Any of the clients. So, there's always like, you know, this testing thing that can become daunting sometimes. Also, you know, as we saw that these server responses can get super large because we are getting the data as well as the view models, you know, performances on and make sure, you know,
it's very well load tested so that, you know, you're not having any sort of optimization of performance issues. So, I do want to talk about, you know, how we use that Robinhood at a very high level. So, these are the screenshots that you see of our ETF pages. So, just to give a background, ETF is some, you know, is a collection of stocks. So, as you can see, let's say, a single ETF will have 25% of technology stocks, you know, 14% financial, energy, and so on. So, all these charts and pages are driven through a server-driven UI at Robinhood. What this means is that, let's say my product comes to me and, and, you know, is like, here Kangsha, we want the technology sector to look like red, because we feel,
you know, red appeals more with technology. It's just a single line of code at the server side and, you know, that will just go across all the three different platforms. So, it's as simple as that. So, it's giving us a lot of flexibility to control all these various, you know, components, colors, and layout that we have. So, not just that sort of data, like all the charts that we have in through an SDUI. Any chart, you can simply think about it as the granular level, XY coordinates, and, you know, these are the points that make segments and, you know, the lines. So, let's say if I want to add more charts, add more points to the chart, or like maybe extend my chart left and right. It's as simple as to, you know, make a
server side change and, you know, it will be reflected across all platforms. So, I do want to, you know, summarize the talk with, you know, sort of like some key takeaways that SDUI is super powerful, you know, very fast development and it, you know, helps with iterations. Saves a lot of time by avoiding duplicative implementations, especially like the diversion behavior that, you know, my team had in the start. But yeah, power comes with responsibility. So, it's not a silver bullet solution. So, one thing that comes to my mind is, let's say your product case is a very small basic app that has a lot of static data, then using SDUI might be over-engineering. So, make sure that you look at the pros and cons and
depending on what stage are you in, you know, the right call. And with that, thank you everyone for, you know, attending this session. I can take any questions if you have. Feel free to put them on the chat. Thank you. Glad you guys liked it. And if you have like any questions, you know, later on, feel free to connect to the Women in Tech or my LinkedIn.
Uh, yeah. So, one question here is, what was the main reason you decided to switch to SDUI? A great question. One of the major reason was that we have a lot of moving parts in our app, as you saw, like the ETF sections, the charts. And one common trend was, we are doing a lot of like user research, right? So, you know, there are a few components that users prefer to have over the left or right, you know, just to make sure what appeals to them better or, you know, helps with. So, exactly, as you said, you know, AB testing. So, this really helped us to do faster AB testing and these sort of experimentations. How hard was the migration process and how did you sell this idea to the
business? A great question again, Vira Lakshmi. So, the migration process a lot depends on, you know, do you have a framework in hand? Uh, if, you know, you're starting from scratch, um, like the, it's, it's not really, it was a, you know, multi-month set of process where we did like several iterations having like, you know, milestone one, milestone two. So, for example, the first idea was to just move the static data, you know, uh, to SDUI and then charts was like a fast follow-up. Um, selling the idea to the business was really going back into the backlog, you know, the backlog that we get from product and, um, you know, consolidating the ideas that, that where the shipping time can literally be, you know, a day or two where we've been, you know, scoped like weeks to, you know, get that product
out to the audience. So, um, like putting that, you know, one pager with the TLDR and, you know, pointing out a quest that had happened in the past to show them that value of, you know, how, how much value this can bring to the company. I hope that answered your question. Uh, any more questions in the last few seconds? Looks like, no, thank you so much for attending and yeah. Um, see you, see you around.
Thank you. Bye-bye.
Transcribed automatically; names checked against the speaker record. Select a time to jump there.
Article based on this talk
Can server-driven UI cut mobile release cycles from weeks to days?
Robinhood engineering manager Akanksha Gupta explains how moving rendering logic to the server sped up her team, and where the approach stops paying off.
In short
Akanksha Gupta, Engineering Manager at Robinhood, argues that server-driven UI (SDUI) lets teams ship and experiment far faster by sending both the data and the instructions for how to display it from the server. Her team used it to remove inconsistencies across iOS, Android and web and to move releases from weeks to days. She is equally clear that it brings real costs and is not the right choice for every app.
Key takeaways
How to iterate and ship products to customers faster using server-driven UI
How server-driven UI differs from conventional engineering
The pros and cons of server-driven UI, and whether it is a one-size-fits-all solution
Robinhood's engineering team journey to server-driven UI for its charts
Why thick clients slow teams down
Gupta opens with the situation she inherited when she joined the Robinhood team that owns the stock detail pages, the Robinhood charts and the shareholder experience. All three clients, iOS, Android and web, were "super thick", with most rendering logic living on the client. One of her first projects was estimated at several months across platforms, and the platforms did not even look the same. A button was left-aligned on iOS and centre-aligned on Android, and the reason was mundane: "Because there were two different engineers at two different times implementing, you know, the similar design of the app." (1:15)
The traditional release path compounds the problem. Developers build the layout, package it into the app, submit it to the App Store or Play Store, wait for review, and then hope users update. As she puts it, "The biggest thing here is that even once this is done, we are really at the mercy of our customers to go ahead and update their app version so that they can make use of the latest features." (3:07) She adds that when a high-severity issue appears, app versions cannot easily be rolled back, so a fix means another trip through the same cycle.
How server-driven UI works
In SDUI, the client still sends a request, but the server responds with a data model and a view model: what to display and how to display it. Gupta notes that many companies use JSON for this, though XML and other formats are possible. "The big advantage of this approach is that you are offloading a lot of your logic from the client to the backend." (5:51) One source of truth on the server can then power all three platforms.
Interactivity does not disappear. Triggers and actions, such as what happens when a user taps a button, are predefined on the client. Once a client component knows how to render a button from a server response, "This means you can actually set up a button, anywhere on your app, without any client side change." (7:53) Common elements such as labels, buttons and carousels can be templated in the same way.
To make the concept concrete, she walks through an illustrative response (not Robinhood's implementation) for a home screen titled "Fruits". Each item carries its data, such as a label and likeability percentage, alongside rendering instructions like "button", a colour and dimensions. A single response describes the full collection of components that make up the screen.
What teams gain
Gupta lists the advantages her team has seen: logic written once and shared across platforms, the ability to add or remove UI elements from one central place, and much shorter release cycles because server deployments follow internal approval rather than app store review. "So, in the market, and personally, we've gone from like weeks to literally, you know, matter of days, like as soon as you have the change in, and your server deployments can be controlled through internal approval process." (11:26)
That speed makes A/B testing practical. It also eliminated the divergent behaviour her team started with: Robinhood's iOS, Android and web apps are now consistent in the data and charts they show. Thin clients also mean faster mean time to response when remediating high-severity issues.
The costs: nothing comes for free
Gupta does not oversell the pattern. "So, since nothing comes for free, it also has its own challenges." (12:18) Because the client has no context on the UI, the framework itself must handle client interactions and logging. Designing the right backend abstractions is hard, especially deciding how deeply responses should nest: "So, it's more think about it more like a recursion, like you can go as deep as you want, but you do want to have a boundary somewhere." (13:19)
Testing becomes more daunting, since a server change can break every client at once. And because responses carry view models as well as data, they can grow large, so they need thorough load testing to avoid performance problems.
Robinhood's charts and the migration
At Robinhood, the ETF pages, which break an ETF down by sector such as technology, financial and energy, and the charts behind them are driven by SDUI. If product wants the technology sector shown in red, "It's just a single line of code at the server side and, you know, that will just go across all the three different platforms." (14:55) Charts are treated as X and Y coordinates forming points, segments and lines, so adding points or extending a chart is a server-side change.
In the Q&A, Gupta explains that user research and A/B testing of component placement drove the switch. The migration was a multi-month effort in milestones: static data first, with charts as a fast follow-up. To win business support, the team went back through the product backlog and wrote a one-pager showing work scoped at weeks that could ship in a day or two.
Her closing caution is the most practical advice in the talk: "But yeah, power comes with responsibility. So, it's not a silver bullet solution." (15:42) For a small, basic app with mostly static data, SDUI may be over-engineering.
Watch the talk
"Rapid Iterations with Server Driven UI" by Akanksha Gupta, 19 minutes: https://www.womentech.net/video/rapid-iterations-server-driven-ui-akanksha-gupta
About the speaker
Akanksha Gupta is an Engineering Manager at Robinhood, where she leads full stack teams building products that give customers a better trading experience. She previously shipped promotions and pricing products at Amazon (Audible), worked as a tech consultant at Microsoft, and holds a Master's in Computer Science from Columbia.
Questions this talk answers
What is server-driven UI?
Why is traditional mobile development slow to iterate?
What are the main challenges of server-driven UI?
When is server-driven UI not worth adopting?
How did Robinhood migrate to SDUI and sell it to the business?
Drafted with AI from the talk transcript. Editor review pending.
Frameworks and ideas mentioned
Server-driven UI (SDUI)
A/B testing
MTTR (mean time to response)
Cite this talk
Akanksha Gupta. "Rapid Iterations with Server Driven UI." WomenTech Network, 2022. https://www.womentech.net/video/rapid-iterations-server-driven-ui-akanksha-gupta