Load-Time Function Randomization (LTFR), that prevents memory-based attacks, which constitute approximately 70% of exploits.
LTFR works by uniquely randomizing the memory location of every software function each time a program loads
making it impossible for attackers to predict where to inject malicious code.
Unlike traditional antivirus or basic ASLR
RunSafe's protection is integrated at the software build stage and has zero performance overhead at runtime, making it suitable for embedded systems.
A U.S. Army analysis showed RunSafe's technology reduced the attack surface of a system from...
A U.S. Army analysis showed RunSafe's technology reduced the attack surface of a system from 12,000 potential memory-based exploits (gadgets) to zero.
The technology provides resilience against known and unknown (zero-day) memory-based vulnerabilities
breaking the costly and unsustainable cycle of constant patching.
By mitigating entire classes of vulnerabilities
RunSafe helps manufacturers reduce the economic burden of patching, testing, and recertification, ultimately speeding up time-to-market.
Guest Joe Saunders argues that this type of protection is vital for national security
as it can defuse "cyber bombs" pre-positioned by nation-states in critical infrastructure like energy, water, and medical systems.
While RunSafe stops memory-based attacks
other security measures are still needed to address the remaining 30% of threats, such as those targeting the file system or involving compromised credentials.
Episode Summary
In this episode of The Med Device Cyber Podcast, host Christian Espinosa is joined by guest Joe Saunders, the Founder and CEO of RunSafe Security. They delve into a proactive and innovative approach to cybersecurity designed to immunize software against entire classes of attacks, with a particular focus on critical infrastructure such as medical devices, defense systems, and industrial controls. Joe Saunders explains that his company's mission is to move beyond the traditional, reactive cycle of patching vulnerabilities. Instead of constantly chasing the next exploit, RunSafe's technology aims to make systems inherently resilient, so that even if a vulnerability exists, it cannot be successfully exploited by attackers.
The core of their solution is a patented technique called Load-Time Function Randomization (LTFR). Saunders describes this as a highly advanced form of memory randomization that goes far beyond standard Address Space Layout Randomization (ASLR). Every time a device boots or software loads, RunSafe's technology uniquely scrambles the memory locations of every individual function within the code. This creates a different memory map for every device, every time it runs. As a result, an attacker who develops a memory-based exploit (such as a buffer overflow or ROP chain attack) in a lab environment finds their attack rendered useless in the field, as the memory addresses they are targeting are no longer predictable. A key advantage of this method is that it is implemented during the software build process and has no running code or performance overhead at runtime, making it ideal for resource-constrained embedded systems common in medical and industrial devices. Saunders cites a U.S. Army analysis which found that RunSafe reduced the number of potential attack gadgets in a system from 12,000 to zero.
Beyond the technical details, the conversation explores the broader strategic and economic implications of this technology. Saunders argues that the current model of endlessly patching is an unsustainable "treadmill" that incurs massive costs in development, testing, and recertification, especially in regulated industries like medical devices and aerospace. By immunizing software, companies can reduce the urgency of patching for memory-related vulnerabilities, saving significant time and resources and speeding up their time-to-market. Furthermore, Saunders frames this as a crucial element of national security. He discusses how nation-state actors are pre-positioning "cyber bombs" in critical infrastructure, waiting for a moment to detonate them and cause widespread disruption. By making these memory-based exploits fail, RunSafe's technology effectively turns these cyber bombs into duds, hardening the infrastructure that underpins modern society and, by extension, protecting democracy from such threats.
Frequently Asked Questions
Quick answers drawn from this episode.
In this episode of The Med Device Cyber Podcast, host Christian Espinosa is joined by guest Joe Saunders, the Founder and CEO of RunSafe Security.
RunSafe Security offers a proactive defense, Load-Time Function Randomization (LTFR), that prevents memory-based attacks, which constitute approximately 70% of exploits. LTFR works by uniquely randomizing the memory location of every software function each time a program loads, making it impossible for attackers to predict where to inject malicious code....
Joe Saunders explains that his company's mission is to move beyond the traditional, reactive cycle of patching vulnerabilities. It's most useful for medical device manufacturers, cybersecurity engineers, regulatory affairs professionals, and MedTech founders preparing for FDA review.
RunSafe Security offers a proactive defense, Load-Time Function Randomization (LTFR), that prevents memory-based attacks, which constitute approximately 70% of exploits.
LTFR works by uniquely randomizing the memory location of every software function each time a program loads, making it impossible for attackers to predict where to inject malicious code.
Share this episode
Pre-fills with: "RunSafe Security offers a proactive defense, Load-Time Function Randomization (LTFR), that prevents memory-based attacks, which constitute approximately 70% of exploits."
What if a medical device could prevent an attacker from exploiting a vulnerability, even before a patch becomes available? Joe Saunders, CEO and co-founder of RunSafe Security, joins Christian Espinosa to explore a different approach to protecting the software inside medical devices and other critical infrastructure. Joe goes through how RunSafe's technology changes the way software functions load into memory, making certain exploits ineffective without introducing the performance demands typically associated with additional security software. But the implications extend beyond stopping an attack. For medical device manufacturers, vulnerability management can create significant development, testing, and regulatory challenges. Could preventing exploitation at runtime also reduce the burden of patching and help companies get products to market faster? The conversation explores the economics of cybersecurity, the threat of compromised software updates, and why increasingly capable attackers are forcing manufacturers to rethink how they protect devices already deployed in the field. In This Episode: 02:44 Protecting critical infrastructure and medical devices 05:25 Why traditional runtime security creates challenges 07:25 How RunSafe protects software without a running agent 11:05 Understanding memory-based exploits 20:59 The cost of constant patching and recertification 25:54 Reducing exploitation risk from 12,000 potential gadgets to zero 28:16 Cybersecurity and faster medical device approvals 30:45 Threats to critical infrastructure 36:24 The danger of compromised medical device updates 38:43 Why AI is accelerating the cybersecurity challenge 40:10 Building security into software from the beginning Connect on Linkedin with Joe Saunders: https://www.linkedin.com/in/joesaunders/ Learn more about RunSafe Security: https://runsafesecurity.com The Med Device Cyber Podcast is brought to you by Blue Goat Cyber, cybersecurity experts providing essential security solutions for the medical device industry. Learn more by visiting https://bluegoatcyber.com . If you're interested in our services or partnering with us, schedule a Discovery Session: https://go.bluegoatcyber.com/meetings/blue-goat-cyber/discovery-session Christian Espinosa is the CEO and founder of Blue Goat Cyber. Christian Espinosa on LinkedIn: https://www.linkedin.com/in/christianespinosa/ Blue Goat Cyber on LinkedIn: https://www.linkedin.com/company/blue-goat-cyber/ Blue Goat Cyber on Instagram: https://www.instagram.com/bluegoatcyber/ Blue Goat Cyber on Facebook: https://www.facebook.com/bluegoatcyber/ Blue Goat Cyber on YouTube: https://www.youtube.com/@BlueGoatCyber/?sub_confirmation=1 Download MP3 — full interview
Guest: what we specifically do is we relocate where the functions load in the memory uniquely every time the software loads. And we demonstrate, like the Army did for us last year, they did a whole analysis, that attack surface went from 12,000 potential gadgets to zero at runtime.
Christian: We've had major medical device manufacturers been compromised this year or in 2026. And from my experience, the attackers were probably one hop away from an update infrastructure for that medical device manufacturer that would have allowed them to push a malicious update to fielded devices. And that could have caused a mass casualty event.
Guest: I do think people need to assume bad actors will get in. And you want to cut 'em off at their knees so they can't do what they tried to do. And when they go to detonate those cyber bombs, they don't work.
Christian: Hi, welcome back to another episode of the Med Device Cyber podcast. Today we have a guest, Joe Saunders from RunSafe. They have a cool tool that's proactively is supposed to stop, I think when I checked, about 70% of attacks. So it's supposed to prevent you from having to patch or do anything because their tool and their product stops the attackers dead in their tracks. Is that, is that an accurate statement, Joe?
Joe: I think it's 100% right. You know, what we try to do is prevent exploitation when software is running out in the field on a device. Um, and, you know, there's all sorts of reasons to do that. One of which is, you know, it's good practice to make sure, um, you know, bad actors don't, don't take over devices, but it also has, you know, some economic benefits as well. So there's a lot of reasons why we do it. Um, and, you know, at RunSafe, I think we're pretty mission-focused. So we try to, we try to, you know, make sure systems remain resilient.
Christian: And where are you coming to us from today?
Joe: So we're based in the Washington D.C. area. We're just outside of Washington D.C. in Tysons Corner. Um, you know, we operate there, but we do have our company spread around a bit. So I'm currently at my home office. We have, you know, um, employees probably in 15 different states in the United States. So that's kind of a fun fact and, uh, you know, today's environment, working remotely over Zoom, having podcasts over Riverside, uh, you know, being able to engage with you, Christian, uh, you know, we're all, we're all just a, a video call away.
Christian: It's like we're next door virtually all the time. Yeah, most of my staff is remote and uh we, I don't know if we have 15 states, we probably have close to 15 states though.
Joe: Yeah.
Christian: And it's interesting as an employer, every state has different rules, employee rules, and it makes it very, very challenging as an employer, at least from my perspective. There's a lot of compliance issues like New York and California and Colorado specifically.
Joe: Yeah, I mean, payroll, unemployment, you know, different uh, regulations, healthcare, who's covered, you know, um, so having nationwide health coverage for a small company, fortunately, there's organizations like PEOs and whatnot that help you out. So.
Christian: Yeah, we're using a PEO to make it a little bit easier. So, I know your background and the background of RunSafe is really for critical infrastructure protection, and healthcare and Med device fall under that. What is your largest, I guess client or industry? Is it DOD really or automotive?
Joe: Yeah, we work across, you know, multiple, you know, verticals, if you will. Um, we, we often support those that manufacture equipment. So manufacturers, device makers, medical device makers, OEMs, uh, and, you know, I'd say our largest category is aerospace and defense, as you can imagine. With the rise of geopolitical tensions around the world, um, you know, there's, there's just a lot of need to ensure that software remains resilient. So that kind of leads us to critical infrastructure in general because our mission is to make critical infrastructure safe. So that also then includes energy and industrial automation, transportation, including automotive, but also rail and aviation, and maritime assets, and of course, medical devices. And then the last category is communications, so routers and switches and infrastructure like that, so satellites. So all of those things, and they all kind of come full circle because in some ways, uh, you know, critical infrastructure affects all the sectors.
My favorite use case is, uh, for whatever reason, I guess it goes back to our very first customer, but, uh, you know, if you think about data centers, data centers need to remain cool. And so there's sensors and controllers and cooling systems inside data centers as part of the operational technology. And so, you know, if the data center, um, loses its thermal controller and the signals aren't reaching the cooling systems, and the data center overheats, then servers malfunction. And I always like to point out then the obvious impact of large language models won't process. And in today's environment, that's part of what's, it's a significant economic driver. So, but aerospace and defense is our most uh you know, our largest sector and we're doing a variety of things for defense and aerospace related use cases.
Christian: So for the listeners that don't quite understand what RunSafe does, because there's a, I think a lot of people think you're like anti-malware, you, you install it, it stops the malware, it's signature-based or anomaly-based. Can you explain a little more detail like how it works? Because for me personally, I'm not, I like anti-malware, I think it's necessary to run an operating system, but it also greatly slows down the operating system. So there's probably a lot of people think, well, if is RunSafe going to slow down my medical device and how does it actually work? Maybe you can get behind the scenes a little bit.
Joe: Yeah, happy to. And as you say, you know, one of the, one of the struggles when you add runtime defense is, you know, so how are you actually enabling the protections? Some people will put software agents on a device, some people will, you know, rely on signatures and do anomaly detection and, and the problem with those, you know, uh, software agents on devices creates dependencies, slows down systems, may require more hardware. So a lot of complexity there. And then if you're always having to constantly update, you know, with the next signature, the next attack, then you're always one step behind the attack itself. And so we wanted to take an approach that would, uh, not always be one step behind the attack, that wouldn't require, you know, constant updates. Uh, and we don't want it to slow down the systems and add software to create those dependencies because that would be a support nightmare for us, but obviously a big problem, uh, you know, for our customers because they, they need determinism in the way their systems operate since they're mostly mission-critical, safety-critical systems, where, you know, you need to really, you know, the reliability and, uh, determinism is a key factor in performance to ensure things work on time and work correctly.
So what we do is, um, as I like to say, kind of a simple formula first, which is, uh, and then I'll explain what it means, but what we like to say is we insert our security protections at build time. So, you know, we integrate with your software build process, um, and insert the protections there. Those security protections get invoked when the software loads on a device out in the field. So we, we invoke the security at load time, and I'll come back to that in a second, for the benefit of runtime protection.
Christian: So, so you're integrated with the software, like you're part of the software or the firmware, not an add-on.
Joe: Correct. We get built into the binary ultimately, but here's the trick. We have no running code at runtime. So, um, when I, when I come back to, you know, we, we get inserted at build time, but invoked at load time, we actually occur before the software loads on the device. We add in our security protections and what we specifically do is we relocate where the functions load into memory uniquely every time the software loads. What that means is we're leaving no additional software on the running device and we don't slow down the device. So there's zero overhead. It works, you know, on legacy software, works on new software, works, um, and there's no performance overhead hit like I said. So, it's kind of a little magic trick because then every device has different, uh, locations where the functions load into memory uniquely every time. So your device, my device, they're all different, um, in terms of the way the functions load into memory. That way an exploit built in the lab doesn't know where to find the weakness or the vulnerability in the first place and can't compromise the system.
So that's how we stay ahead of the attackers, make it simple to implement, and don't create a lot of the common problems of signatures or software agents or anomaly detection in general.
Christian: We're going to go in the weeds here a little bit. Um, how is what you just described different than ASLR or address space layout randomization?
Joe: So, address space layout randomization, uh, obviously it's been a technique around for around, I don't know, I think going back to 2006, 2007. Um, it took about 12 to 15 months for ASLR to be defeated. The reason is it does not do the fine-grained form of randomization that we do. So we're at a far more granular level in terms of what we're relocating. And you can think of ASLR then also as maybe an offset to the memory. So, you know, the problem with that is, you know, if I take the functions and move them all down, say five locations and everything shifts evenly, with one single information leak, I can recreate because it's referential, I can recreate the entire memory map and still allow my exploit, you know, to find where it needs to deliver its payload. So, with RunSafe since we're randomizing uniquely at the function level, um, and it's not referential, uh, that means even with an information leak, you couldn't find the other elements of the weaknesses to string together your exploit to make it work. So, the fine-grained randomization is the key, and that is far superior to ASLR. We call that load-time function randomization as opposed to address space layout randomization. Our load-time function randomization is far different than ASLR.
Christian: So the assumption is, and I used to do a lot of code injection and write my own exploits back in the day and try to do buffer overflows and I understand the the memory and all that. But for the listeners, like how does malicious software actually run? And then what, how do you stop it? And I know you mentioned on a video I watched of you that you said you stopped 70% of attacks, and so there's still 30% that make it through. So maybe explain, you know, how you stop the 70%, like how that works, and how the other 30% uh you're unable to stop or what mechanism they're using.
Joe: Absolutely. So, if you look at a software binary, there may be many, many forms of, you know, attacks and attack vectors. The ones at runtime that are memory related, we stop 100% of those. So our mission is to stop the memory safety related vulnerabilities. And as you mentioned kind of the buffer overflows or the return-oriented programming gadgets and, you know, the, the so-called ROP gadgets and ROP chains, these are, you know, means on which an attacker can grab onto your software and, you know, effectively do what they want. They can get remote code, you know, you know, develop remote code execution, they can introduce arbitrary code, they can take over the stacks, they can take over the heap-based, um, elements, um, and basically introduce or resort, um, what looked like legitimate functions to do something nefarious, something that the developer never had intended. And often times, what you'll see in a call tree in a binary as it's processing is it'll take a few steps, take some jumps and returns and things like that. But if you get on there, and you can find the different, uh, you know, spots, you can string together those functions to do something malicious. And so those are access points, things like buffer overflows and ROP gadgets and ROP chains are means in which an attacker can find, you know, some, some areas to, uh, some surface area to exploit. When RunSafe's invoked, uh, those, you know, rock gadgets, rop chains really are not reachable by the attacker. But if they are reachable, that means they can dive into and reach sys calls and operating system and really kind of muck things up. So our whole aim is to prevent the attacker's ability from kind of taking over that device and introducing that arbitrary code that might do something malicious. So these are runtime attacks, targeting weaknesses in, you know, in the code that lead to memory-based exploits that can, you know, take over devices and and do something nefarious.
Christian: So if it's a memory attack, and attacker can inject some items into the memory, overwrite something, so the next instruction it runs is what they've injected effectively. And there's a couple different techniques for that, but you're preventing that. And then the other 30% of attacks that you were talking about they're not memory-based. Like what type of attacks are those?
Joe: So it could be any number of things. Um, but, you know, if there is some kind of, uh, you know, some people will do secure boot because they want to ensure that the device that gets loaded onto, you know, the hardware is exactly, you know, what you would expect.
Christian: So this is like me booting off of a thumb drive instead of the operating system, which would not obviously load RunSafe.
Joe: Yeah, that's possible too, right? But um, if, if, and if you have that kind of access, then of course, but you might be able to manipulate files and replace files that might do something crazy, uh, if you had access to the file system on the, on the binary itself. So there's any number of things like that. Some people will have, you know, different, um, authentication, um, schemes that are not really runtime memory-based, um, attacks. And so, there's a couple different ways, but they tend to be the more minor ones that are addressed through other means of security. So, the memory-based attacks end up being the high severity ones that are, you know, 8, 9 on CVSS scores, um, why? Because they, they allow someone to take control of the device. And with those known exploits targeting those, it's a real problem and it's hard, you know, one of the challenges that people face is at runtime, um, you know, if there is a zero day out there that's putting, you know, devices at risk, how do you then update all the software quickly? And if RunSafe's employed, then theoretically you don't have to do the update as fast, right? Even if a patch is not available, your system can prevent the exploitation with RunSafe employed.
Christian: If I'm building my own firmware, what I, and I say, I want to have this runtime protection, as an example, would I reach out to RunSafe and say, hey, I want to incorporate your tool into my build, so my router then doesn't have memory, um, exploits available for people? Is that how that works?
Joe: Yes. And so we support a number of different build tool chains if you will. Um, you know, uh, what we don't do is replace your compiler. We work, you know, alongside your compiler. So, um, you know, we have customers that use GCC, for example, um, to compile code. You know, we work in various build environments, so Yocto and Buildroot. Um, we also support many different operating systems on which those applications may be, you know, kind of targeting. We work with, uh, you know, real-time operating systems like Lynx and VxWorks, the X and QNX and and ThreadX and others. Um, we also then are, sort of, agnostic if you will, um, to the, you know, chip architecture. So, you know, what kind of instruction sets are being used and is it a, you know, Intel 86 or ARM 32 or 64-bit processor. Um, we also have some customers that use, um, PowerPC or MIPS, believe it or not. And, uh, with that said, so we're, if you think of the different architectures for the target device, the chip architectures, you know, crossed with the operating systems, a majority of those, we support right out of the box, you know, that matrix. And so in your build process, when you take source code and compile it, and a few other things happen after compilation, right? So you take your source code, compile it, the linker kicks in, stitches things together, creates that software image and all those binaries from the object code, and then when it loads on a device, right, um, things load into memory. You know, the loader loads that into memory. So we're, we essentially put a wrapper around the linker, collect some information about all the functions, differentiate from the data that goes into that binary, and we identify all those functions so that at load time, uh, based on that, you know, build process, we know how to relocate the functions without breaking code and it's, you know, it's a tried and true or proven process that, you know, um, some of the largest manufacturers in the world are using for safety-critical and mission-critical systems.
Christian: There's not just the operating system, there's all the applications on the operating system. And I, because I used to do IT stuff and work with the DOD and was always like the patching was like a nightmare.
Joe: It's a nightmare.
Christian: So then uh in these systems, right? Like, you know, medical devices need to get recertified if they do major upgrades and, and so then there's a cost of, you know, what happens if uh if I have to go recertification, the EU cyber resilience act. What if, what if I have to go through recertification there? And the, in the Department of War, Department of Defense, um, you know, authority to operate is a big deal. And in safety-critical systems like aviation and autonomous driving and things like that, being certified for safety of flight's a big deal. And in certain situations, you may have to recertify if you have major software upgrades to a platform. So that all comes at an economic cost. And so we wanted to change that equation. We wanted to say even if a patch is not available, you're protected, so that you don't have to retest, recertify, maintain, you know, chase vulnerabilities and get in that constant cycle.
Christian: I think it's, uh, interesting 'cause I used to do a lot of DOD work and digital forensics and instant response and I remember a couple cases where a nation state had been on a department of defense network for I think it's almost seven years before they were detected. And you would think out of anyone that would detect an adversary, uh, seven, almost seven years is a long time for someone to be like in your closet of your house and then you, you go to the grocery store, they come out and go through all your stuff and then you come back in, they go back in the closet. It's kind of like, and they're there for that long and we never caught them. You know, it's crazy to think about that. And I, I still think about like, that's probably going on now in critical infrastructure as you alluded to. Uh, here in where I live in Phoenix, we have autonomous driving cars. You kind of talked about them. They have lidar. Uh, we have the Waymo brand and a few other brands here now. But I always wonder like, what if somebody pushes the button and causes all those cars to go crazy? You know, like, what is the ramification? And I kind of think with medical devices, uh, because I was just talking about this the other day, nobody really takes MedTech cybersecurity very seriously, and I think it's because we haven't had, unfortunately, a mass casualty event. And a scenario I like to, not really I don't really like to think about it, but it's a plausible scenario. We've had major medical device manufacturers been compromised this year, in 2026. And from my experience, the attackers were probably one hop away from an update infrastructure for that medical device manufacturer that would have allowed them to push a malicious update to fielded devices. And that could have caused a mass casualty event, but we pretend like that doesn't, that's not going to happen. And maybe it won't. But like you said, we've got probably pre-positioned things. And I'm not trying to, you know, make a, spread fear and uncertainty or doubt. I think it's just a reality of the world we live in and people kind of don't really think about it too much. And maybe, maybe it's better we don't think about it. I don't know.
Joe: Yeah. It could be better not to think about it and, I mean, if you're thinking about an EMP going off and I've got like a portable toilet and some food and some ammunition and stuff, so maybe I think about this stuff too much, I don't know.
Christian: Yeah, I mean, that's, that's a whole, you know, um, that has people concerned. And so, what it does is it accelerates and compounds the urgency in which to solve some of these problems. But it also means that, um, you know, adversaries could develop exploits, you know, in a shorter window. Um, and so we do, and which means we have to respond faster from patching. And I do think that element will become not sustainable. I don't think we can maintain manually, you know, kind of pushing out updates, you know, on a constant cadence and expect to keep up. We're going to have to do something that's automated. So, if it's not the catastrophic event that scares you, I think it's the, you know, the day-to-day grind that, you know, we need to wake up and and say, you know, we gotta come up with a different way. And I think the economics are in favor of trying to eliminate classes of vulnerabilities from being exploited and not chasing individual patches every single time because that's an exhaustive, ultimately losing process because there will be an item that's open, uh, and an attacker will find that, that, um, vulnerability.
Christian: What is, for the listeners, what's one or two key takeaways from our conversation here?
Joe: Yeah, so I think, uh, from, from my perspective, uh, I think it's easy to do an analysis and quantify all this. So the risk reduction analysis I was talking about, I think is a good approach because if you can, uh, ease the burden on developers and increase resilience at the same time, I think that's one great lesson. And you can quantify it for yourself with the data on your devices. So that's easy to do. Um, the second thing is, I do, I do believe, you know, um, there is, uh, you know, ways to add security into your software development lifecycle in a way that inserts security into software as opposed to trying to bolt it on and and really do kind of the network defense and try to pre- you know, the old way is to prevent people from getting in. But I do think people need to assume bad actors will get in and you want to cut them off at their knees so they can't do what they try to do. And wouldn't it be great in today's world if a bad actor spent months trying to prepare this preparation of the battlefield that we talked about, the pre-positioning, and when they go to detonate those cyber bombs, they don't work. Why? Because you are protected from memory-based attacks. And so, you know, I think that'd be a great day that um, when those are thwarted and they're, they're all duds. They're all, all the cyber bombs are duds. So, I think those are the lessons.
Christian: I like it. The cyber bombs are duds. I think something you said that resonated with me, uh, is the economic value for like a medical device manufacturer. So instead of having to fix all these vulnerabilities that we know are going to be in the software, why not just make sure none of them can be taken advantage of, right? And then we don't have to worry about fixing them, it can speed up our time to market, reduce our development time, uh, reduce our testing time, and all these other things. And I didn't think about it from that perspective. I thought more from the resilience perspective, but it's also the the time to market and shortening that time to market point of view, which I think was unique for me to hear you talk about that.
Joe: Yeah, fantastic. You know, it's real dollars, time to market, and so if you can boost resilience and either make more money or save money, it's a good combination. Um, and the good news is it's not hard to do.
Christian: Cool. Well, thanks so much Joe for joining us today. Where can people find you and learn more about RunSafe?
Joe: Well, certainly on the RunSafe website at runsafe security.com. We're also pretty active on LinkedIn. Um, and so, you know, I think if people find this podcast, we'll certainly promote it out. And we're grateful for companies like Blue Goat Cyber, Christian, you guys do a great job and uh, you know, it's great to, great to interact with you in the industry and certainly find ways to work together going forward.
Christian: Awesome. Well, thanks everyone for tuning in. Thanks again, Joe, for joining us from the D.C. area. And we hope everyone found value in this episode and we look forward to seeing you on the next one.