Mike's Notes
A useful shared experience by Leander Vanderbijl at an InfoQ conference. The original InfoQ video presentation includes the slides. and is well worth watching (52:26).
Resources
- https://www.infoq.com/presentations/transforming-primary-care/
- https://www.blog.ajabbi.com/2026/01/managemyhealth-breach-patients-at-risk.html
- https://www.blog.ajabbi.com/2025/11/workspaces-for-health.html
- https://www.blog.ajabbi.com/2024/09/fast-healthcare-interoperability.html
- https://www.blog.ajabbi.com/2024/08/health-systems-in-new-zealand.html
- https://www.blog.ajabbi.com/2024/07/using-health-terminology-standards.html
References
- Reference
Repository
- Home > Ajabbi Research > Library > Subscriptions > InfoQ
- Home > Handbook >
Last Updated
29/01/2026
Transforming Primary Care: a Case Study in Evolving from Start-Up to Scale-Up
Leander Vanderbijl is an engineer and architect that has worked across the entire stack and has been working at Kry/Livi for the past number of years. He has developed large enterprise applications, migrated cloud platforms, designed data query frameworks, architected integration systems and built lots and lots of APIs. Having worked in large enterprises, small companies and, most recently, in healthcare, he has built the monolith, torn it apart and then rebuilt it again.
Transcript
Leander Vanderbijl: Have you ever built the perfect application? Beautifully crafted your models so that everything fits the real-world objects that you think you're going to have in your system? Only to wake up one morning and your PM comes to you and says, yes, that's great, but what if it just did this a little bit differently? With that one sentence, your entire premise is thrown out the window. All of your assumptions are proven false and your beautiful system is impossible to work with. What about that perfect architecture you've developed? Very clean, you've got onions and layers and all of that fun stuff, and it works perfectly. You don't know when and you don't know why particularly, but over time you suddenly come back to it and this beautiful application has become a spiderweb's nest of impossible dependencies. I've been there. We've had that problem.
In this talk, we're going to talk about how our company, Kry, has evolved through startup and scaleup phases, and particularly how our systems have evolved while we were trying to find our product market fit, and how our systems became that spaghetti spiderweb's nest of dependencies.
Particularly, we'll look at how we're now applying domain-driven principles to gain back control of our architecture, to try to make sense of the mess that we built. Again, not intentionally did we build that mess. We're also going to look at how we're changing our mindset from looking at the product and taking a feature endpoint. Our frontend needs this so I'm going to build one endpoint for that. Instead of doing that, we're starting to think about, what functionality do we need to provide for any client or for any other part of the system? We're going to look at how we're moving from an organic approach to our software evolution where people just do what they need to, when they need to, to a much more deliberate and targeted approach to our evolution where everybody knows where we're going.
Marshall Goldsmith says, what got you here, won't get you there. Which is a great quote as long as you know where there is. Throughout this talk I'd like you to remember my golden rule, my guiding principle, working software is better than the promise of working software. We're not Google or Microsoft. I can't go and tell a team to rewrite the OS every four years. We have to find some other way of making our systems better in situ.
Roadmap
For the structure of this talk I'm going to borrow heavily from Simon Brown's C4 model. We're going to look at this problem at four different levels. We're going to start at the company profile. We'll talk a little bit about what our company does and what its purpose is. Then we'll move on to go a little bit deeper to the container level and look at our product history and our requirements and how those have evolved over time. Then we'll get a bit deeper still and get to that component layer and look at how our architecture and our services have grown and adapted over time. Lastly, we'll look at domain modeling, sort of a code level. We won't look at code but that code level of the C4 model. We'll look at how our domain modeling has changed over time and how it's evolved when we started to realize that our initial attempts at it weren't fitting the bill.
Tech in Hardware
Did you know that in the UK there are 353 million GP patient appointments every year? There are 28,000 full-time GPs. Is anybody good at math? I do that for you. That average is somewhere in the neighborhood of 30 patients a day, or 3 to 4 patients an hour. At Kry, we've found that by applying technological solutions in a process that we call digital offloading that we can increase this throughput from 3 to 4 meetings an hour to somewhere in the neighborhood of 7 or 8 meetings an hour, so nearly double, and still provide the same levels of clinical excellence. We do this through a series of things.
A large part of that is moving the meetings online, and that has proven that we can improve throughput just by doing that alone. A lot of it is really around all the rest of the provision of services that go around meeting a patient. That's things like being able to get data in a timely and efficient manner to the GP before they look at a patient. That's mastering the workflows after the patient has been seen by the GP. All the data input, we can standardize that. We also can vastly improve the workflows for continuing care, things like prescriptions or providing referrals and things like that. With all of that that's how we can really drastically improve the speed and the quality in which our GPs can manage the patients.
Company Profile (Context)
We were started in 2015 in Sweden. As we grew, we started to expand into other parts of Europe. Primarily, our biggest markets are France and the UK. We've also recently gone into Norway as well. Again, our focus is the digital transformation of primary care.
Product History (Containers)
Let's go into how our products have evolved over time. When we started in 2015 it was simple. All we wanted to do was hold meetings digitally online. The requirements were again pretty straightforward. Obviously, I'm simplifying this a little bit. Really all we had to do was we had to allow clinicians to be able to meet with patients. We had to be able to get reimbursed, that's the important part, from the national healthcare system particularly in Sweden. We had to be able to share data with the national healthcare services. That's both getting data and being able to write data back to them.
As we grew, we added more requirements and more functionality. Things became naturally more complicated. We added prescriptions. When we moved into other parts of Europe we started having to deal with more complexity. We had to deal with regional differences. Things like in the UK the reimbursement model is based on a fee per action, so we get paid for every patient appointment we have. Whereas when we built the system in Sweden the Swedish model is based on capitation, which means that the patient has to be registered with your clinic in order for us to be reimbursed. They were very different models of getting reimbursed. We also had to deal with a lot of different security and regulatory differences.
Things like age of consent, dealing with children and things like that. We started adding new clinical types, so new health services. Things like mental health, nursing services. These services had very different workflows to the original GP workflows. We started opening our own physical branches and we started having to deal with different scheduling models.
Particularly, we started to have to deal with separated schedule books. Each physical practice would have their own separated schedule that had to be maintained and managed differently from all the other schedules. This was something that was a big difference because originally when we were just digitally online, we just had one big pool of doctors who would serve us a queue. Most recently, we've added insurance companies and private companies who want to provide our services to their employees as a benefit. This has added more workflows that we had to manage. With insurance workflows we have to be able to make decisions on the fly as to whether or not we can see that patient. That means we have to be talking in real time to insurance third-party APIs and be able to make complex decisions on the go. We also came across issues with data sharing.
In the UK, for example, if we see a patient through an NHS contract, we're allowed to use NHS APIs and NHS data. If we see that same patient through an insurance workflow, we're not allowed to use any of the APIs. We're not allowed to use that data either. Suddenly, we had to start understanding, who is paying for this appointment, and be able to make decisions rapidly as to what data we could use, what APIs we could use and the like. That's a plotted history of our product.
Architecture and Services (Components)
When we started, life was simple. We made this ourselves, maybe you can tell. Again, life was easy. We had clinicians and we had users, and they could have meetings. We could store their data in what we called, and I still don't understand this joke, the fax machine. It was ok. It worked. In fact, it worked really well. We could scale quite easily with this service in terms of the volume, and life was good. We started having patients and we started increasing the number of patients we were seeing. We started adding more functionality. We added the ability to manage prescriptions. As we grew, sometimes it was quite easy for us to add new services because you could fit it in or you could do things. Sometimes, for example, when we had to add new payment models when we moved into the rest of Europe, things became more complicated. We had made assumptions about our payment systems and our payment models when we started in Sweden.
Suddenly, when those models changed, we had to work out how to fit them in. Sometimes we could fit that in just beside the code we'd already written. Other times that would be too difficult and so we'd have to create a new service. The same thing happened across the board when we added mental health services, for example. Mental health services are a very different workflow. They don't necessarily revolve around one meeting with a patient like we had with a GP. You might have a dozen meetings or more meetings, all part of one service as you were. We had to build another service to manage that, and the trend continued. When we moved into physical, we started dealing with queues and scheduling. We already could do queues and scheduling in our meeting service, but we couldn't separate them nicely so we had to refactor parts of that. We had to build a service to go with it to manage some of that complexity.
It was at this time that we really started to see that maybe what we had initially thought, wasn't as perfect as we had initially thought. Things were starting to change. When we started having physical meetings we realized, yes, we've got patients as well. When we started, users were patients and patients were users, and it was simple. Who's a user in a physical sense? We also at this stage started being able to see children. Somebody worked out that children might have parents, we didn't really think about that.
Then, some really clever guy, real person, realized that actually a child might have two parents and they might have two separate accounts. How do we deal with those relationships? We made this work but it wasn't pretty. Remember, this is all through our startup phase. We didn't have the luxury of stopping, pausing everything, and refactoring a bunch of code, refactoring some of our main assumptions. Our primary goal was to get customers in the door. Our primary goal was to try to get profitable, and so we were doing everything we could to make that happen. I must stress this, that wasn't the wrong decision. We absolutely had to do that. If we hadn't have done that, I probably wouldn't be here today. These are decisions that are made because of the situation that you're in, and that's fine.
At some stage, you are going to have to deal with the technical debt you've built. Our insurance workflows were so drastically different to what we had built before that we actually built pretty much a stand-beside service to handle a good chunk of our insurance workflow. We started having duplicate code because we couldn't make it work otherwise. We started complicating the systems that we had.
This was a very organic approach. When we started, we didn't really know where we were going to go. People just did what they needed to do. At the beginning, again, remember this was easy. Our dependencies were very straightforward. You could see which service needed to talk to which service and how things should go. Over time, as we added more services and we added more complexity, those dependencies grew. We didn't have any rules about who could talk to what or when.
Basically, if you needed it, you could build it. We started to realize that our services were no longer really fit for purpose. Many of them grew so bloated through just constant addition of different functionality that they hardly resembled the purpose for which they'd been started in the first place. We had also the opposite problem where people couldn't be bothered or didn't want to wreck what was already there, so they'd create a standalone service often for a very tiny bit of functionality. What was even better was that people didn't necessarily talk as well as perhaps we should have, and so we started to duplicate. Sometimes we had multiple services doing very similar things, but one very similar thing. Again, this is natural. You've got a company that's growing very quickly and we're trying to get as many customers through the door. We lived with it and it worked. We did get customers through the door. Our architecture grew very flat.
Everything could talk to everything else and there were no rules around it. We knew that our services were no longer becoming a cohesive API that anybody could use. Instead, they just became really a big collection of endpoints. Things were starting to become problematic. It was difficult for us to extend. It was difficult for us to change anything. We spent probably two years knowing that this was a problem. It's very easy to identify that you've got a problem. It's a lot harder to actually work out how to fix it. We tried all sorts of things. We went to the bosses and said, can we just stop doing everything for a couple of years and rewrite this? You can guess what their response was. We thought, what if we just decided to do a version 2 of our APIs? Maybe we can just fix the problems with that API.
That failed too, not because they didn't do good work but because we didn't really know what we were building. We were just trying to fix our perceived problems with a very small part of the API without taking the entire picture into view. Remember my golden rule, working systems are better than the promise of working systems. We knew we weren't going to start from scratch, and we knew we had to do it in situ. We realized, the most important thing we had to do was we had to agree on where we were going. We had to stop all pulling in different directions and work out what it was that we wanted to do, and then move in that direction all together. It didn't matter if people took little deviations here and there, as long as they weren't going backwards or southwest.
This is where domain-driven design came to the rescue. We had all of these services and all of these systems that we knew about and we listed them. There's some of them here. This is where we took the decision to flip what we were doing from looking at the product down and look from the functionality up instead. We'd gotten to a stage now that we were mature enough that we did start to understand our systems reasonably well or at least what the functionality needed to be. We didn't have to kowtow to the product team and build a brand-new thing every time because by this stage we'd built most of the functionality. We could start thinking about it in the opposite way. We sat down and we started to think about, what is it that we actually do? What's our core business? We didn't do this in a big team. We tried to do it in big teams. We tried to crowdsource this, and we just had too much whataboutery. There was just too much, what about this edge case? That's not going to fit that. It became counterproductive.
In the end, we had to make a decision. We had to try to decide where to go. We just made a small team and said, we're going to make this broad and we're going to start somewhere so that we can get going in one direction. We sat together and we said, what is it that we do? We do healthcare. That hasn't really gotten us that far, has it? At least we know we don't do bananas. This is what we have now, one big domain of healthcare. We knew we had to dig deeper, and this is where we actually got really pleasantly surprised because actually when we looked at our services it wasn't that hard to start grouping things in big buckets.
In fact, we went right back to the beginning and said, what were we trying to do? We were trying to have meetings online. We looked and we saw we had meetings, we had users, we had a queue service, schedule. That's a bucket. That's really easy. I don't need a PhD in rocket science to work that one out. We put that into a bucket and that became our first domain. Again, things seemed very simple. We looked at what was left, and again we started to realize that actually some of this was quite straightforward. We had patients. We had prescriptions. We had different service types. We were storing their data. We had ways to do referrals. We had all of these services that were really around providing that medical service to a patient. That became a domain called medical. We had two great pillars there ready to go, and that felt really good.
Then we went, we're forgetting probably the most important part of this, how do we get paid? We realized that the payment systems and our reimbursement models and all of that stuff, our contracts, that those things were definitely a domain on their own because they changed for all sorts of reasons, a new government, a new payment model. That became a third domain where we could isolate all of that, let's call it crazy, on its own.
We had three brilliant pillars and that felt right, but we still had a bunch of services left over. We had no idea where these would fit. We had a bunch of services around messaging. Messaging was used by parts of systems in all of those domains. It was used to communicate with patients. It was used to communicate with our contract with the NHS or with GP surgeries. It was used between clinicians to communicate. Where does that go? We also had a bunch of services around EMRs, medical record systems. That's where your patient data is stored. We had a bunch of services that were connecting to different medical record systems.
Again, these were used by all of the domains. What were we going to do with those? We didn't really know. We didn't want to have a handful of separate domains standing on their own, so we did what any sane person would do and we fudged it. We created a domain that isn't a domain, really. We created something that we just called support systems, and whatever didn't really fit or was used by multiple domains we put into that. We were left with a very simple model of what we did. This reduced our cognitive load when we had to start dealing with new functionality or new systems. It meant that our developers didn't have to worry about 50 services when they were adding functionality, but they could just deal with the one or two that were relevant to their domain.
We got here. We know what we're going to do. How do we go from there? Domain-driven design to me is a journey, it is not a destination. I never expect us to get to what that domain looked like. We might but I doubt it. As we go, as we develop, as we work towards that domain, things will inevitably change. Requirements change. Our understanding of the problem changes. We have to expect that that's going to happen. The beauty of that was that it wasn't super specific. It wasn't like anything was going to trip us up, but it all gave us a unified idea of where we wanted to go. It was something that everybody could get behind. What got you here, won't get you there. At least we now know where there is. Let's take a look at a few of the approaches that we used, not to get us to domain driven, but to move us in that direction.
The first one I call the take that approach. The take that approach is where we have a bunch of singers who are all right on their own, but we put them together and they become greater than the sum of their parts. You remember I was talking about those medical record systems. We had a good dozen or so different services that managed our connections to medical record systems. They were used in different ways by different parts of the code at different times. We started to have a couple of duplications. We'd have code in two different areas calling the same EMR in a different way because they needed a slightly different outcome or a slightly different result. All of the different connections to those EMRs were implemented totally differently. All of the code that used those systems couldn't just talk to a different EMR if we wanted to change, they had to rewrite or reorder how they were using them.
One thing about all of these EMRs is that they weren't consistent at all. The way that you had to get data from each of them was different. They all had different models for the data. They all had different ways of connecting to them. For some of the systems, or a lot of the systems even, you could connect over HTTP. There are some systems that you can only connect to locally through a TCP port. We actually had to have a VPN into some of these systems. That complexity, coupled with the fact that we were just duplicating all of this logic all over the place, seemed ripe for simplification.
Again, nothing fantastic here, but this was perfect for an adapter proxy pattern. We created a single proxy at the top where all of our clients could connect to if they wanted medical record data. They could connect to a single consistent API and get a single set of domain models back. If they wanted to connect to a different medical record system, they'd just call the same one and just say, I want it from a different system. In one swoop, it standardized all of this complexity. We hid all of that complexity in the EMR connectors. The EMR connectors would be responsible for translating from the medical record system to our domain models, and we'd have one connector for every external EMR. It became very easy for us to now just talk to a different medical record system, because all we had to do was add another connector. We didn't have to rewrite all of the code from top to bottom. That was the take that approach.
The next approach is the opposite of the take that approach, the Robbie Williams. The Robbie Williams approach is where you take the one singer in the band who's actually any good, and you get rid of the rest. I apologize to all of you take that fans. We had a REST Entity called care facility, and there were over 40 endpoints dealing with a care facility. Thirty-one, I think, when we counted last, of those endpoints, were just one variation or another of getting a care facility. You can see we got creative with the naming. We've got with a hyphen, without a hyphen. We've got a plural. We've put physical in there. We had a second version. Again, this is obvious, but we came to this and went, that's a bit mad, isn't it? Most of these endpoints, the only difference between them was they would call by a different column, they'd filter by a different column. We had all these endpoints. We had two versions of our APIs.
In behind all of that, in our code, we had 15 different service classes, all basically just querying a care facility. We had five different data access objects, all for a care facility. We realized we could just take this and make this simple. We could just have one query endpoint. The way we did this, we'd already tried this, and you can see that with the V2. We didn't want to go down that road again. What we decided to do was that we'd start off with our brand-new single query endpoint, we'd go through each of those 31 endpoints one at a time, and we'd make sure that we could match the functionality in our new query endpoint. We'd go from top to bottom on our systems and get all the calling code, point it to the new endpoint, and then we deleted the old endpoint, so that every time we went through a new endpoint, we knew we'd gotten rid of it. It was never going to stay around anymore. That allowed us to take our 40 endpoints and get one endpoint, one version, one service, and one data access object.
Domain Modelling (Code)
Let's move on to our domain modeling. This was what we started with. Again, it was simple. We designed this ourselves, and it matched what we knew about the world when we started. We had users who could have a meeting. We had clinicians who could join that meeting. We knew who was paying for it. We would store some data. The way that we were able to really dramatically speed up the way that clinicians would handle our meetings was that we standardized using forms, and that made it really quick and easy for clinicians to go through a meeting, fill out the information they had, and move on. It was also great for us to be able to review those meetings to ensure that we were still providing the same levels of clinical excellence because we were standardized. The forms were hugely important for us, but when we stored the data, we stored the data in the format of that form because that's what made sense at the time.
As we grew, that started to show its age. Forms would change over time. If we want to look at an old meeting that was written in an old form, and we've got the data, how do we render that form again? We had to be able to match those things, and that became difficult, especially with more iterations. We had to support UX that was old and things like that. Because the data wasn't stored semantically, we had no way of being able to ask the kinds of questions you would expect to be able to ask of a system like this. How many people have we seen for COVID-19? We could answer those questions, but it was really difficult.
One of the other aspects we had was that you can see that everything was revolving around the meeting object. The meeting was really our central pillar for understanding our system. As we started adding new workflows, that assumption started to become invalid. When we had mental health services, we had to be able to manage a service over multiple meetings, and so things were starting to get strained. We talked about users being patients, and patients being users, and them not being the same thing. Again, we realized that our model was starting to strain at the seams. It was starting to become difficult to use. It was starting to show some of the frailties.
We had a look, and this was different from our approach to services. We decided here, this is a healthcare model. This is a popular industry in the world, I think. Maybe somebody has done this before. Turns out they have. FHIR stands for Fast Healthcare Interoperability Resources. It is a full schema and model for healthcare objects. It's used around the globe. We were like, "I don't know why we didn't find this a couple of years ago, but excellent. We've got it now. This will solve all of our problems". No, that was bad timing. It's great. It is fantastic. It's a beautiful set of resources and models that have been really well thought out. Anything you could possibly want in the healthcare space is catered for.
The fact that they've been able to manage all of the complexity that occurs around the world with a model like this is amazing. Some of the things you might notice here is that in order to support all of that variability, they've had to make it fairly abstract. Things like the patient name isn't a name, it's a human name. Inside the human name, object, or a bunch of smaller objects. If you look in the contact relationship, you've got a codable concept. You'll see that codable concept in the communication language. You'll see it in the marital status. Codable concept is basically a namespace key-value pair. That's fantastic because it allows us to model all of these things or allows them to model all these things without being too specific. Can you imagine your frontend developer who wants to get the first name on a screen shouting at you when he's like, what do you mean I have to go through eight different objects to get the first name?
It was great for telling us how things should look, but it wasn't necessarily great for every implementation that we would need. When we took this model into our medical domain, it was like the lights came on. It made sense because everything was specific to the much more narrow domain in which we were working. We had patients. We don't have users. We had appointments instead of meetings. We had clinicians. Clinicians are clinicians. Instead of this random set of forms and data that we had, we had observations which were strongly typed, so we could now start asking questions like, how many people have we seen for COVID-19? What was fantastic about doing this exercise was that when we started looking at the other domains that we had, it started to make a lot of sense. We could see where the objects in the different domains met. We could see how they related to each other. We could also see why they weren't the same thing anymore. This was a massive step forward for us.
Let's move to my last approach that we used around how we dealt with domain models. That's the approach formerly known as Prince. This is where we take a system that works and that is useful and that we quite like, but we realized that there was actually another service, a hidden service that we hadn't identified at first that would better suit part of our requirements. That we'd had one service that was actually trying to do multiple things, and it did both of them badly. It would be better to leave the service as-is for the things that it was useful for, but to build a new service for the things that it didn't do well.
This is what we did for our medical data. We took the FHIR model and we built a new data service from it using FHIR, not directly, but as an inspiration. We did think about using it directly, but then we got to that, how are we going to tell the frontend developer that he's got to learn FHIR and learn these complex models? We didn't. We used it for what it was good for. We took the best bits, particularly the objects and the relationships between the objects, and then we modeled the properties as made sense for us and for our systems. Now we can very easily query our data. We've got a given name there, so our frontend developer is happy.
This drastically improved our understanding of the system because we no longer were tightly coupling our patient data to how it was inputted. It allowed us to be able to make changes in the input forms without having to worry about the backend. Things become simple in small doses. There are three approaches, the take that, where we can get a bunch of things that seem similar, maybe they're not rockstars in their own, but we can put them together and they'll be greater than the sum of their parts. We can have the Robbie Williams approach, where we take the one good thing that you have and then delete all the rest. We have the approach formerly known as Prince, where we rebrand or rework some of the functionality that we've discovered we needed at the time, but we still can use the old stuff because the old stuff is still good.
Summary
Remember, you are never going to be in a situation where things don't change. People are always going to be coming to you and asking you to make new things, to build new things, to change how they work. You have to lean into it and you have to accept it. We've used domain-driven design very successfully to reorganize how we think about our systems, even the ones that are already running. Lastly, I'd really recommend that you organize around the functionality that you have, not around what the product says they need, because, remember, domain-driven design is a journey, not a destination.
Questions and Answers
Dr. Kreindler: How do you think larger health systems can get to 11 out of 10 in terms of their whole architectural strategy? Because right now it feels like most of us are at 1 or 2 out of 10 in large health systems.
Leander Vanderbijl: There's a lot at play. There's a lot of perceived complexity, I think, in the healthcare industry. I think a lot of that complexity isn't necessarily complexity, but it's just different ways of working. Trying to convince people to move towards a standardized approach to things, which isn't necessarily a be-all and end-all in and of itself, but has proven very successful for us, can be difficult. We go to practices and we say, if you do things this way, we can really improve your throughput, we can really improve your services.
A lot of people go, yes, but I can't do it that way because we use a fax machine or whatever. A lot of that is changing people's minds. There's a lot of vested interests in terms of how systems work, and maybe not even necessarily vested interests, but medical data is very protected, rightly so. That makes it very difficult if you want to start doing novel things with it. It makes it very hard to get around some of those hurdles and to be able to convince large organizations like the NHS or other things to be able to allow you to get into data, to do things that maybe are slightly off the beaten track.
Dr. Kreindler: You talked about domain-driven design. By that, I'm assuming you're talking about the different components of the business, are you, or domain as in the healthcare domain?
Leander Vanderbijl: It's more in a software perspective. It's how we group our functionality together to be able to make it easier to understand and to develop.
Participant 1: With the increasing role of tech companies in the government sphere, do you think we'd ever get to a point where governments themselves are agreeing on data models or other interfaces, like the FHIR one, that could make just business on the international scale easier?
Leander Vanderbijl: Yes. In fact, the NHS has adopted this wholesale. In fact, their latest set of GP Connect APIs are all FHIR-based and they are brilliant. There's a lot that people complain about the NHS, but their GP Connect APIs are absolutely brilliant. They're very well thought out, they're very well modeled. If you can get access to them, they're amazing. It is difficult because they're under a lot of pressure. There is a lot of governance you need to go through to be able to get access to them, but they are fantastic. It would be nice if the private companies that had medical record systems would support FHIR as beautifully as the NHS does, and that's actually been almost more of a problem than the national healthcare systems.
Participant 2: Domain-driven design is obviously very good for informing your software, but to what extent, when you've drawn your models, you've mapped out domain, you understand what your software currently does. Can those models maybe inform back on the product side of things, go, actually, what you're suggesting here, we're moving into a new domain? Are we losing the purity of the focus? Are we maybe changing direction a bit? Can it shake back and affect the product as much as it affects the software that comes out of it?
Leander Vanderbijl: Absolutely, it can. The way you model things can absolutely impact how well you can do certain things. We had the instance with the way that our data was stored, we couldn't answer a lot of the questions that we wanted to ask. Once we started storing it in a model that made sense, in a domain that made sense, we suddenly could ask those questions, but we could also ask a lot more that came up, because they were like, "You can do this. Yes, I hadn't thought about that kind of question". Absolutely, it's a two-way street there. Definitely.
Participant 3: To paraphrase, "We drive down costs and increase efficiency by standardizing the business workflow of medical care, domain-driven design being a great way of standardizing IT systems". I totally agree. I'm a big fan. Have you thought about the next step, so, for example, 4C analysis in the business workflow to further drive optimization? Given the data you now have or the personnel you have, how you could use something more like 4C to drive the actual outcomes in the medical business, because it's a different approach to try to drive different medical outcomes through process change.
Leander Vanderbijl: Absolutely. The trick there is around governance. How long can you keep data like this? Are you allowed to use it for other purposes, like training data models or that sort of thing? That's a bit of a minefield at the moment. I think there are still a lot of people trying to work out the ins and outs of that. We are starting to do things like automated triage, so being able to say, given a set of complaints, do they need to be seen tomorrow, yesterday, or whatever?
Participant 3: After domain-driven design, have you thought about what would be the next thing that you would implement, like a 4C analysis or something else?
Leander Vanderbijl: No is probably the shortest answer. Again, this is a journey. What we want to do is see where it takes us, really, and try not to be too prescriptive of where we're going to go. Once we start getting the initial domains starting to make sense, then we have the time to start looking deeper and fixing some of the other problems. At the first hurdles, we're really fixing the top layer of problems. We do need to go deeper into some of the way that some of our other code is written and some of the problems that are there. That's natural.
