Maayan Shvo: Hi, everyone. Again, welcome. Thanks so much for joining us today. The purpose of today's session is to explore how agile and CI/CD can bring speed and compliance together, even for a device as complex as one that includes AI or machine learning. So, very exciting stuff ahead.
We're going to introduce ourselves in a bit. Just before we begin, a few housekeeping items. This webinar is being recorded and will be sent out with the slides following the conclusion. We'll also, of course, share other resources in the chat during the webinar. Please go ahead and put questions in the Q&A at any time.
Our colleagues are on the line, and they'll be surfacing your questions from the chat to us throughout the presentation. We'll, of course, do our best to answer as many questions as possible live. We also have an incredible team of subject matter experts staffing our chat today to answer any questions we can't get to on the air. If you have to leave at any point, of course, that's okay. You'll see a survey that we'd really appreciate you completing.
It's going to give us feedback on this webinar. And finally, there's a link that Joe posted in the chat to register for our next webinar, so you can go ahead and do that at any point. So first off, the reason we're here today: I want to introduce Ketryx. Ketryx is an AI-native compliance platform purpose-built for life sciences to deliver safer products faster.
How do we do this? We interoperate your tooling across the various teams in your organization and apply your QMS rules across it all. And with that data, we can also automatically generate the compliance evidence and documentation that you need.
And with our AI agents, which Bailey will demo later on in the presentation, we can automatically trace requirements, assess change impacts, validate test coverage, and flag compliance risks in real time. For quality teams, this means less manual chasing of evidence and more confidence in audit and submission readiness. For R&D teams, the benefit is more time spent coding in developer-enabled tools, in the environments they're used to, not in manual documentation. Okay. And now over to you, Bailey. Tell us who you are.
Bailey Canter: Yeah. Thanks, Maayan. Hello, everyone. Welcome to our webinar.
I'm Bailey Canter, director of solutions here at Ketryx. A little bit about me: my background was originally in physics. I got my degree from UNC Chapel Hill, so go Tar Heels. Then I went on to be a systems engineer in the defense space, working on a product line at Raytheon. After that, I worked as a back-end software developer, and in that role I was also the scrum master and release manager.
So I got to see both ends: writing requirements as a systems engineer, implementing them in the source code, and then trying to gather all of that and put it together for release readiness, and ultimately how challenging it can be to be agile in a regulated industry. Now I'm very happy to be here at Ketryx to help teams solve similar challenges to the ones I faced in my previous roles. Our solutions team here is dedicated to doing just that. We work with teams in the medtech space who have complex systems. They're trying to deliver expert care to patients.
And they run into similar challenges with trying to automate that evidence of compliance. So our solutions team works intimately on the presales side to help clients create solutions that use Ketryx, an AI-native platform, to help automate that evidence of compliance and to embed that compliance workflow into the way you work. So that's a little bit about me and our solutions team here at Ketryx. Excited to chat more about agile today in the webinar. And now I'll pass it over to Maayan.
Maayan Shvo: Yeah. Thanks, Bailey. I can attest that Bailey's team can help you with your problem, big or small. They will come up with the solution. My name is Maayan Shvo.
I'm the AI lead at Ketryx. My path took me through both academia and industry. I was fortunate to be able to do research at companies like IBM, Samsung, and Philips, even in the healthcare domain. My PhD in AI focused on agents before they were cool, focusing on beneficial agents. And I'm very happy that I ended up at Ketryx, where some of those ideas from my research landed in real-world use, both internally and with our customers, in the shape of our agents and our assistant, which are QMS-informed. Informed by your QMS, the specific customer's QMS, and really have an understanding of your organization and your regulatory needs.
What's really cool about AI at Ketryx is that we use it ourselves. We epitomize dogfooding, and we use it internally.
And I see how impactful our assistant and agents are internally for our teams, as well as, of course, for our customers. And because Ketryx is built at the quality of a medical device, we're using that AI, building it for internal and external use, and it helps us understand customers' needs in this space, because Ketryx is such a unique piece of software. So I'm very excited for Bailey to be showing you those agents later on in the presentation. Very happy to be at Ketryx, and let's talk some agile, AI, and ML. So now that you know who we are, here's what to expect from today.
Here's the agenda. We'll start with why agile development is difficult in regulated environments, as many of you presumably know, then explore why AI and machine learning raise the stakes and add new challenges. After that, we'll cover process changes that make agile really work safely in regulated development. And finally, we'll look at how combining agile with CI/CD enables continuous compliant releases.
Bailey will also show you an amazing demo of Ketryx applying agile methodologies in tools like Jira to develop an AI-enabled device. So I hope you're all very excited, because I surely am. Before we dive in, we'd like to get a sense of where everyone's coming from. So if you will, look at the poll area in the chat there and try to answer the question: What development methodology does your engineering team use? Waterfall, agile, agile with CI/CD, some hybrid?
And Bailey, I'm sure you've seen many kinds of teams come to you with different engineering methodologies. Right?
Bailey Canter: Oh, yeah. Absolutely. I've seen it all, and I've worked in it all, from Kanban to traditional scrum to waterfall.
I've seen the pros and cons of each, the benefits and the challenges of trying to work in all of them. And typically, I see a combination of them all. It's really hard to be truly agile or truly waterfall. So I'm interested to dive into that and see what methodologies the folks on the call are using.
Maayan Shvo: That's awesome. Same here. Let's see. Our poll will be closing soon.
And we see here in the results, which I think you can see in front of you, the plurality of votes goes to agile with CI/CD, but then also this hybrid mix of agile and waterfall. So really, there's a good mix here, but a lot of you are using agile or some hybrid that includes it in the mix. The results are still... and that's it. We're going to put on the slides again.
There we go. And over to you, Bailey, to now take us into the world of agile.
Bailey Canter: Yeah. Thank you, Maayan. Thanks, everyone, for your responses to the poll.
Now that we have a sense of your current development practices, we will begin by laying some foundational groundwork on agile itself. We'll start with a brief introduction to the agile methodologies referenced in the poll. Agile, on the left, is a flexible project management approach that breaks projects down into smaller iterative phases called sprints. Each sprint aims to deliver an increment of code that can be tested, improved, and deployed independently, aiming for continuous improvement, flexibility, faster feedback loops, and continuous innovation. However, for medtech teams aiming for the same speed, the challenge arises because every single iteration must be meticulously tied back to requirements, risks, and test evidence to comply with stringent standards like IEC 62304, ISO 13485, and ISO 14971.
So the problem arises when you try to work agile while complying with those standards. What this leads to is teams working agile in one system while documenting waterfall in another. I think we saw that a little bit in the poll, a bit of a hybrid of both. Waterfall, on the right, is that linear, sequential project management approach. It emphasizes establishing detailed requirements and then designing, developing, testing, and deploying in a waterfall, structured, phased way with predictable timelines.
In this approach to project management, you're trying to align to manual checkpoints, which creates a cascading effort of updating artifacts. So you're not able to move iteratively or in a cyclical nature like agile does. So what is really at the core of this dilemma? We see teams, like you saw in the poll, that are doing a combination of agile and waterfall. But why is that the case?
Why do we struggle to be purely agile or purely waterfall? Let's dive into that a little bit. On one hand, we have the promise of agile: speed, flexibility, and continuous improvement, which lead to fast releases and innovation. This is what R&D teams crave.
On the other hand, we have the reality of regulated medical device development. You have to have meticulous documentation, traceability, and evidence for every change. This is what quality teams must ensure. So how do we maintain the speed and flexibility? How do we reconcile these two seemingly opposing forces?
We think that this disconnect between agile development and waterfall is really a disconnect in trying to generate that documentation and that evidence of compliance. So how does this align with the V-model? On the left, we have teams working in ALM tools like Polarion and Windchill, which are naturally built for compliance with IEC 62304. On the right, we have your SDLC tools like Git and your CI/CD pipeline. But we have this gap in between that often leads to manual copying and pasting to try to get information between your ALM tools, which are great at complying with standards like 62304 but are maybe more waterfall-like, and the tools on the right, which support agile.
This can mean that change management becomes very painful, because every update requires rechecking requirements and risks across disconnected systems. And then you bring AI-enabled devices into the mix, and the problem becomes even worse. You're in this endless cycle of working in this area in the middle, copying and pasting information between these two frameworks to get that full cycle and understand the full management of your product. In this sense, true agility can feel impossible. At Ketryx, we believe that automatically generating the evidence of compliance is how you fill that gap.
So I hope that's a good segue into our next topic, which is the complexity of introducing AI into products. Maayan?
Maayan Shvo: Yeah. Thanks so much, Bailey.
We've been talking about agile and regulated development. And Bailey alluded to the fact that when you throw AI into the mix, everything gets even more complex than it already is. So let's zoom in on AI. AI and machine learning are very heavily set in the current zeitgeist, and they're really changing how medical software is being built and updated.
But of course, not every organization is at the same stage of adoption. So it's time for yet another poll, to get a sense of where the audience is. We'd just like to know: How advanced is your organization in introducing AI or machine learning into your products? Are you not exploring yet, in early exploration or a research phase? Maybe you're already piloting some use of it. Maybe you have some limited use of it in production, maybe for some of your products, or maybe it's core to your product.
So let us now turn over to the poll. And Bailey, I'll put you on the spot again. I'm sure you get teams across the spectrum in terms of where they are in integrating AI into their products. Right?
Bailey Canter: Yeah. Absolutely. AI has become a hot topic recently, and that's not news to anybody here. Especially when talking with enterprise clients, they're really excited to figure out how we can use AI in our current workflows, and how challenging that can be for a lot of reasons. How do you naturally integrate it with your tool stack, as well as validate it and ensure that every change you're making with AI is tracked and can be trusted?
Maayan Shvo: Absolutely. There's a lot of uncharted territory and waters there that we're all managing. Right? When I joined Ketryx, I was so thrilled to see all the subject matter experts we have on hand to offer a steady hand in these, again, uncharted waters. And as we've been developing AI internally at Ketryx, which, again, is built to the level and the quality of a medical device, we've been applying the same methodologies that we use to develop Ketryx, and that we offer our customers, to develop our AI.
So, as I mentioned earlier, that gives us a very important perspective into the needs of our customers, many of whom, from this poll, are integrating AI into their products. So that's very cool to see, and you are in the right place for this webinar. As this poll is closing, we see here, it's very cool, we see a nice spread.
We see in the poll results a bunch of people already piloting. Some even have it core to their product. Some are in an early phase. So it's really a nice spread here. And I think the message of this webinar should resonate for everyone, wherever they are on that spectrum.
And of course, across the industry, we're seeing a rapid rise in AI- and ML-enabled devices. That's evident also from this small poll that we conducted, not just in volume but also in the breadth of applications. We're also seeing what regulatory authorities consider to be medical devices evolving over time.
For example, AI scribes for physicians are being considered a medical device in certain regulatory domains, which they weren't even a year ago. AI is moving well beyond radiology into surgery, cardiology, drug delivery, and even manufacturing and supply chain. For example, our customer HeartFlow develops AI-powered noninvasive cardiac imaging software, just as one example. And the chart on the right really shows how regulatory approvals for AI-enabled devices have accelerated in the last decade, with especially sharp growth in the past few years, likely due to the advent of generative AI and transformer-based AI techniques like LLMs.
The key takeaway for us is that AI is no longer just a niche. It's no longer few and far between. It's become foundational across diagnosis, treatment, and operations, across many fields. And as Bailey mentioned, agile is already challenging in regulated environments, but AI-enabled devices raise the bar even higher in terms of complexity. Unlike typical software, these machine learning models require frequent retraining and revalidation.
You want to make sure that your AI-enabled device, for example, is aligned and appropriate for its real-world uses. And agile tools just don't capture those events or the evidence that regulators expect. The datasets these models are trained on also change quite often.
And even small shifts, even changes to the training methodology, can really affect safety and performance, which is really what we care about. That can break the traceability back to requirements and risks, which is a big no-no. On top of that, AI devices release smaller updates more frequently. And instead of making teams more agile, this just amplifies documentation overhead. It slows the teams down, which is the opposite of what we want.
AI, of course, also requires expanded post-market monitoring and ongoing drift detection. These are continuous compliance tasks that just don't fit neatly into the agile sprint cycles that Bailey talked about. Let's now dive a bit deeper into model drift and data drift, since they create unique risks that make agile especially hard in regulated environments, and the FDA has fortunately recently offered guidance on this. Perhaps one of the strongest arguments for agile in AI-enabled devices comes from recent research from the FDA at SPIE Medical Imaging 2024, a paper titled, and this is a mouthful, as usual for academic papers, "Quantifying Input Data Drift in Medical Machine Learning Models by Detecting Change-Points in Time-Series Data."
This paper was presented by FDA researchers, and it showed that you can statistically detect drift in real-world medical data streams very early. This result from the FDA researchers sounds like really good news, and it absolutely is. But it also means that you, as an organization, as a product, will be detecting this kind of statistical drift more often.
And every such detection is a potential retraining and revalidation spend: more documentation overhead and so on and so forth. So the challenge is that in a waterfall process, that frequency becomes untenable, unmanageable.
Each detection triggers a massive revalidation cycle that can take even months. So teams either delay acting on drift, which is risky, or performance quietly degrades, also not desirable. In an agile and CI/CD process, drift detection is exactly what you want. The pipeline absorbs the signal.
Now you retrain, you revalidate, you regenerate your compliance artifacts, and you ship a safe update quickly, which is awesome. So what's the main takeaway here? This paper makes the case clear. Early detection only delivers value if your development process can actually keep pace.
Without agile and continuous integration and deployment, which Bailey will introduce more in just a moment, early detection just creates a bottleneck. Agile is the key to safe, continuous AI and ML releases. And in the context of Ketryx, how can Ketryx monitor data drift? Well, as a best practice, teams should write automated tests for detection of data drift.
They check for performance issues or data drift in their models. And they can use whatever testing system they use with Ketryx. We integrate with a bunch of platforms, including GitHub, TestRail, and others. And if any one of those tests fails, Ketryx will actually prevent a release from moving forward until the issue is resolved.
And of course, teams can use the Ketryx assistant and agents for AI recommendations on how to write these drift detection tests. So that's really cool. And now back over to you, Bailey, to take us deeper into agile and CI/CD.
Bailey Canter: Awesome. Thank you, Maayan.
Really cool to hear your perspective as someone who works so closely with AI, and to hear your take on it. So thank you for walking us through that. To take a step back, I think it's really important here to walk through continuous integration and continuous deployment, so CI/CD. I know that teams here are already using it, and that's great, because CI/CD is really central to being agile. With continuous integration, we're making small code changes in a shared repo that are automatically built and tested, helping you catch problems earlier.
And then with continuous deployment, we're automatically running that CI pipeline so that you can push those changes out automatically, so that new features and bug fixes can go live within minutes of being built and tested. Together, they form the CI/CD pipeline that automates your build, test, and release. In the agile world, this is exactly how you move quickly. Agile is really the framework, and CI/CD is how you implement the speed, the agility, the flexibility of agile. So why is CI/CD so important, especially for medical devices?
Firstly, it's about speed. It's being able to get those changes into the hands of users, whether that's bug fixes or new features, and that is exactly the promise of agile. Then it's about quality. You want to make sure that you catch bugs early, which means they're often cheaper and easier to fix. It's also about reducing risk: because you're making small changes frequently, if we have an issue, we know exactly which change likely resulted in that issue and can roll back changes quickly.
And then in regulated development, CI/CD can also drive compliance. That means, with the right setup, every pipeline can generate that evidence of traceability and enforce your QMS. So that's where we see CI/CD really shine in helping solve the agile dilemma, giving you both speed and safety. To take this a little bit further, we see the strengths of agile. We see the strengths of CI/CD and where they bring really big advantages.
But what teams find is that when you go to actually implement this, especially in a regulated industry, you also bring about challenges when it comes to validation. That's again because every single change requires meticulous documentation, evidence, and revalidation. So while agile and CI/CD thrive on constant change, in a regulated industry you have a lot of checks that you need to go through. So fast and quality may not go together with teams' current setups. There are some things that you can do, and I'll propose them on my next slide, that you can set up to really allow you to use agile and CI/CD so that documentation isn't so much of a burden and you can create that evidence of compliance as you're working, with every iteration.
So this is how we really think of implementing that and how to create that strategy. First is making sure that you set up the correct architecture. That's really taking a complex system and breaking it down into a system-of-systems architecture where you can code, deploy, and test each of those subsystems independently, but also manage it at the top systems level as well. Excuse me. The second is embedding testing alongside your development.
That's utilizing automated tests in your CI/CD pipeline. And then thirdly, making sure you have end-to-end traceability set up as you're working. And then Ketryx can really help you enforce those procedures and automatically generate that evidence of compliance as you're working, so that a lot of these artifacts aren't afterthoughts once you've finished coding but are really being done as you're working. That's really where we see the strength of agile and CI/CD combined. And so with that, I'm really excited to show you how we take these four steps into the Ketryx platform.
Alright. I'm going to share my screen now as we transition to the demo environment.
Maayan Shvo: AKA the best part of the webinar.
Bailey Canter: I know. Everyone's always like, "Alright, just get to the slides."
Maayan Shvo: Meat and potatoes. Absolutely.
Bailey Canter: Alright. At this time, I'm sharing my screen. Maayan, are you able to see my screen okay?
Maayan Shvo: I am. Yeah.
Bailey Canter: Awesome. And feel free to use the chat to ask any questions.
We'll try our best to answer them live or have our team answer them in the chat as well. I'll also save five minutes at the end of this demo for questions. For those of you who haven't seen the Ketryx dashboard, the Ketryx platform, before, welcome. We're very excited to walk you through how you can implement agile in regulated industries, integrating directly with your CI/CD pipeline, and also adding the complexity of an AI tool as well. Here, we're looking at the Ketryx platform, and we're managing multiple different projects.
We're utilizing that system-of-systems architecture I mentioned to manage this project that references a GenAI platform. Each of these projects that you see here contains all of your design controls, your design inputs and outputs, and it's connected to the preferred tool you're using, whether for requirements, source code, or test management. And like I mentioned, each of these projects can contain its own workflow and its own approvals so that you can release them independently and on different versions. We're going to work toward releasing this Case Insights Validated project, which is a top-level project referencing this GenAI platform. This GenAI platform also has some of its requirements in Jira, and we're connected to a Git repository as well.
And you can see we're utilizing version control to allow these two subsystems to be on different versions and to reference each other as well. Over here on the left is this Complaint Processing Validated application. This is another product that references the GenAI platform to do complaint processing, utilizing that system-of-systems architecture to maximize reuse. In this case, we'll only be looking at these two subsystems for the demo today. We'll first go into this Case Insights Validated application.
We'll see some work that needs to be done to get this to release-ready, and that will involve going to the GenAI platform and creating a test case for an automated test that lives directly in the source code. We'll release the GenAI platform, and then we'll go back to the top-level project and release the full product. In this way, I hope to elucidate how easy it can be to connect to your CI/CD pipeline and automatically generate the evidence of compliance to quickly go ahead and release this full product. Alright. So let's dive in.
Again, we'll first take a look at this Case Insights project, and I'll jump straight to the traceability matrix. This Case Insights project has, I think, seven columns, a seven-column matrix here, with user needs and system requirements managed in Jira at the top level. And it's referencing some requirements, some software items, and some test cases, and you can see they're acting as risk controls here, which is what RC means. We're referencing these from items that live in the subsystem to populate this full traceability matrix. And then again, we have test cases at the verification level and validation level being pulled in.
Now, this is a real-time view of traceability. This isn't something that gets created as an afterthought or after your development is complete. We're building this traceability matrix and allowing you to easily understand where you may have gaps in traceability or where you need some work to be done to get this to a release-ready state. We embed some design controls at the top here that allow you to easily understand where you may have those gaps. You want to make sure that, in some cases, you have all your design inputs covered by design outputs.
Checks like that can be created at the top here to make sure you're working toward that release-ready state. And this traceability matrix is highly configurable. We work with many teams with many complicated workflows that have different columns, different workflows, and different item types to build out that traceability. So we work with teams to build out the traceability matrix that they're used to seeing, or that is native to their workflow. Okay.
The other thing I wanted to show you was how we use our AI assistant, agents, and AI intelligence throughout our platform. This assistant here is able to understand all the context in our system-of-systems architecture, so it can see all the items in this top-level project as well as the items that live in the subsystem. To give you a better understanding of what we're building here with you today in real time, I'm going to ask the assistant: "Tell me about what the Case Insights Validated application builds." Great.
So this will give us a little bit of context into what we're building here. In this case, we are actually using the GenAI platform to get some health insights about patient data. And I can expand this here to show you exactly what the AI is doing to generate a response for you. I asked it just to tell me what we're building here and to get some more context around this Case Insights Validated application. The assistant responded, telling us a little bit about it.
It's a personalized health insights and recommendation platform for diet, exercise, and sleep using AI technology. And we have some key features here that it used, again, to gather this information not just from the system but from the subsystem as well. I think this is extremely helpful, especially in industries where you have a lot of subject matter experts, or SMEs, that you need to go to for information. With our assistant embedded into your workflow, it understands the full, broad picture of everything that's going on in your system, so that you can allow the SME to work on dedicated, value-added work and reference your assistant for information like this. But our assistant doesn't only gather information.
You can also ask it to write a test case for me, for example. I may need to provide it with the name. So not only do we connect to all of the different platforms to provide you with the most relevant, accurate information about your system, but you can actually take action, write requirements, and write test cases directly with this assistant here. It can even review your requirements and make suggestions to update them, to make sure all of your requirements are written in a testable way.
So here, we've actually analyzed this, and you can see with this highlighting that this is the requirement we're analyzing. All I did was pass it the title, and it says, "I can write a comprehensive test for you here." It looks like there's already one created; I think that's what it says here, I'm summarizing. And so we can review this suggested item, and it went ahead and wrote this test case for us with relevant test steps.
So this is just one way to work very quickly but in a controlled way, always requiring a human in the loop and keeping a robust audit trail. Great. I could talk about our AI capabilities forever, really. But instead, I'm actually going to switch into our GenAI platform. Again, this is the subsystem that contains the code for this Case Insights full product, connected to Jira and Git.
Jumping in here, we're going to look at the traceability matrix. You can see that the traceability matrix is missing something: we have a test case that's missing for this transparency and auditability requirement. So let's go in and create that test case for this requirement. I've cheated a little bit here and already written the test case, just for the speed of this demo.
But I'm going to check out this specific branch that we're working on. This is the branch that Ketryx reads to know that I'm writing test cases, so I can automatically report all of this evidence over to Ketryx and build that traceability. So here I can say "@test," which is me using the Ketryx tagging language to build that traceability as you're working. This allows your developers to stay in their preferred developer tools and build traceability. You can think of this like conventional commits, where you're tagging it to the Jira item, and this is what I've done here.
I've actually just used the Jira ID to build that traceability. And because Ketryx integrates so deeply with your CI/CD pipeline, we can go to the actions here and see that a CI/CD build is being kicked off. This is running that build artifact. It's running those automated tests for you. And then what it's going to do is actually report those test results over to Ketryx.
And I can show you exactly how it does that. Right here, again, we're showing this test mode, or the workflow that we've gone through. We set up the job, we've run dependencies, and we've reported all of that over to Ketryx. And if I jump into the workflow file, I can show you exactly where we're doing that. Right here, you can see that we're reporting tests directly to Ketryx with that success or that failure.
And jumping back over to Ketryx, I'm just going to do an automatic sync here for you. Because we integrate directly with your CI/CD pipeline, we can gather all those builds and all of those commits for you. And you can see that here in the history. All of my commits are connected to my repo, and I can track them here and also use this to generate evidence of compliance for every commit and every build that I've created. So going back to the traceability matrix, we just wrote a test case together.
We ran that automated test after I built traceability. And now you can see that this requirement has a test case, and we can see that the result of that automated test execution is passed. Now that we have all checks passing and we're green, we can jump to our release dashboard and see where we're at in this release process. Jumping to version 1.2, this is the version we're working on together to release this Insights platform. I'm going to pause here at the release dashboard.
This is another very valuable check to determine where we're at in our release process. Do I have all of my design controls, dependencies, and test executions run? You can see all of the items that are in a controlled state. You can make sure all your design controls have passed, as well as test executions. There's a lot of relevant information here that you can use to understand where you're at in release readiness.
And then we can also go to all the documents, which you can see is the next step we need to complete in order to be release-ready. So clicking over into the documents module, I can look at all of the documents that I need to complete or submit to the FDA, for example. With just a click of a button, I can go ahead and generate all of those documents. What's happened is, because I've made a change to an item that lives in the source code, any document that references or relies on that underlying item, whether that item lives in Polarion as a requirement, in Jira as a story, or directly in the source code as a test... we connect to all of those systems, we ingest that information, and we automatically put it into a document for you.
So again, this documentation effort is a byproduct of the work you're doing. And so I generated all of the information that I need to get this into a release-ready state. Now I can put my Part 11-compliant signature on each document to make sure we're getting this ready for the release date. We embed these Part 11 approval workflows directly at the item level or at the document level as well. And you can see, as I'm quickly moving through these documents, how easy it is to track the changes you're making to each document.
I just clicked this clock here to show that we keep a robust audit trail of every time we generate a document, the changes we're making to the document, and who approved it and when. And you can see that record is created right here. Okay. Moving through to the last document that we need to complete to get this to a release-ready state, we can now see, great, we've approved all of our documents.
We kept an audit trail of all of those changes. And now we can go back to our release and see where we're at in releasing this subsystem, the GenAI platform. You can see now that all of our checks have passed, and we're ready to go ahead and release this subsystem. So I'm going to approve this, again using my biometric signature to approve this release. And together, we've just released version 1.2, and that confetti is always so rewarding.
Maayan Shvo: Congratulations.
Bailey Canter: Thank you, Maayan. And I did it with the help of all of you here on this webinar today. So just to recap what we did at the subsystem: we navigated to the GenAI platform, which, again, is a subsystem connected to our Git repository. I kind of glossed over the All Items screen, but I think now is a great time to go back and center on this All Items screen.
I mentioned that we're connected to Git in this GenAI platform, as well as Jira. This All Items screen acts as the centralizing place to easily understand every item in my full lifecycle. And I'm saying "item" because that's a term directly from IEC 62304. We break your steps, or your SDLC, down to the item level so that you can work on each requirement, each change request, each CAPA, approve them independently, and then use that controlled workflow to contribute to the automatically generated evidence, like we just saw on the release screen. And of course, like the traceability matrix, this is highly configurable.
These are the default item types that Ketryx has out of the box, but we work with teams to create epics, stories, bugs, whatever you call the items in your system. One of the key advantages of the Ketryx platform is that it's highly configurable. This configurable workflow allows teams to really pick up the platform, because we adapt to your current ways of working. We're not really a disruptive tool that makes you change the way you're working. We're really an added measure on top of the way you're working, to enhance your workflows and automatically generate that evidence of compliance.
So going back to this All Items screen, we can see all the items that live across our system, no matter where they actually live, whether it's a requirement acting as a risk control. We can see what state they're in. Another strong feature of the All Items screen that teams use is that it really acts as a change control board. We can see every change that we've made across our systems, with exact redlines to show us those changes. Ketryx, because it integrates with all of your systems, creates that robust audit trail for every single change.
Having that is real evidence to an auditor that you're keeping track of every single change you're making in your system. In this case, we've just updated this UUID because I reran the test and didn't make any changes to the test case. But you would see those redlines right here. And down below, we're looking at the Ketryx version of this item. This is actually a test case that lives directly in the source code, and we're viewing it right here.
We're seeing the information that's implemented directly in the source code here, as well as the approvals and the relationships between records. So going back to the traceability matrix, we approved everything here. We released the GenAI platform. And now let's go back to that top-level Case Insights Validated application. I'm going to jump into this graph view here to show you a different view of the architecture.
We're again at that top-level Case Insights platform. We're referencing the GenAI platform, and this is the Insights platform we're using. And these are the different modules being implemented in that GenAI platform. Of course, you can download this as a CSV or Excel file, and you can use that feature across many modules in the Ketryx platform. You can just look at changed items here and export them as Excel or CSV from the All Items screen, and the traceability matrix here you can download as a CSV, Excel, or Word file as well.
Great. So now we're back at that top-level Case Insights project, and we're ready to release it because we just went in and released that submodule, the GenAI platform. Going into this top-level release, we're working on version 2.0. You can think of this as your product release, even though we just released the GenAI platform at version 1.2. Again, this is the release dashboard, but we've used some milestones at the top here to implement those maybe more waterfall-like structures.
So far, we've really seen how we can embed agile practices using the Ketryx platform. We integrate directly with your CI/CD pipeline to gather those automated test results. We use the All Items screen to very easily understand change management. All of this inherently supports agile. It's how teams are using Ketryx to speed up the way they're working.
But of course, like we mentioned earlier, some things are naturally waterfall, and maybe that's requirements gathering. You want to make sure all of your requirements have been gathered and approved, that you've had a meeting about it, and that you have meeting notes generated, all of that maybe before you start coding. So Ketryx has the flexibility to embed those more waterfall-like activities using milestones for each release. In this case, we have some milestones for requirements gathering, for defining the system architecture, and for releasing the GenAI platform right here, which you can see we just did together. So now all that's left is system integration testing.
For the purpose of this demo, I actually set it up so that you don't have to release this milestone in order to release this version. But this is the type of check and enforcement that you can apply. You can require that your teams release or approve those milestones before you can actually release your product. So now that we've released the GenAI platform, and I was ready to go with all of the other changes at my top-level platform, you can see that because we understand all of our changes, and we made small changes in incremental steps, we know exactly what's changed at both the component or submodule level and at the top level. Because we understand our changes and can use our system-of-systems architecture, we know not much else is changing, and we have high confidence in that from our controlled items and our design controls here. Maybe we need to rerun some top-level tests, which is indicated by this milestone.
But like I said, we'll leave that unattended for now. So let's release this product together. Again, I'm going to use my biometric signature to approve this top-level product, and now we've just released that product version. This is how you can have a GenAI product, a product that relies on an AI algorithm that requires frequent updates, maybe retraining or dataset updates. You can easily go ahead and make those changes in the code, connect to or create a CI/CD pipeline to automatically run tests and builds, and report that evidence over to Ketryx, with us tracking all of your commits and all of your builds for you, and then we put that into the documentation for you.
So let's go take a look at one of those documents that we automatically generate. We'll open up this SRS here. Great. In this case, we've opened up an SDS, which is a Word document of our system design specification. This is again ingesting information from the underlying platforms, like the items that live in Jira and your test cases that live directly in Git.
So we can see how we automatically generate these documents for you. I tried to expand it to make it a little easier to view, but it looks like that didn't help. So again, these are items that live in those connected systems that are being formatted directly into your test report, your test plan, your risk matrix, your change plan. All of that can be automatically generated by Ketryx tracking the changes that you're making in the underlying systems. Alright.
That is the bulk of how we use Ketryx to help teams speed up development, create quicker releases, speed up release time, and integrate deeply with agile and CI/CD in regulated industries, especially when you bring in the complexities of using AI platforms. Maayan, is there anything I missed or that you wanted to add?
Maayan Shvo: Yeah. I think that was really awesome. Thank you for that demo.
I think Ketryx really showcases how to combine these deterministic, enforcing processes that are informed by your regulatory and QMS needs with, again, harnessing the power of generative AI in the form of our assistant and agents to really help guide users through that process. They're not alone in that scary, daunting world of regulation. And of course, the user always has control, so when the AI makes suggestions, users choose whether to approve or not. But combining those two, these very powerful deterministic processes that Bailey showcased together with our AI, we have one heck of a system. So that's really awesome.
Bailey Canter: Yeah. Thanks for that, Maayan. I think we are... Yeah. I was just seeing if there are any questions in the chat that we can answer live.
So I see a couple here. Can you see them?
Maayan Shvo: Yeah. I can see some. And yes, of course, for those who had to drop, no worries. We will share the recording afterwards and make it available to you to refer to and share with your teams. One question in the chat was: "Our team prefers using user stories as product requirements, and there's no clear way to track what's being overwritten. This often leads to a chaotic and inconsistent requirements document, which becomes problematic when submitting to regulatory agencies. Do you have any advice?"
Bailey Canter: Yes. I have lots of advice. This is actually a very common challenge that teams face: you're using user stories, maybe in Jira, as product requirements, and you want to keep track of all of the changes being made. What Ketryx does, because it integrates with your tools like Jira, where maybe your user stories are being written, and maybe your requirements are written in Polarion, is integrate with those tools.
We have bidirectional sync with tools like Jira to keep track of all of the changes that are made. And then we can also write requirements for you based on user stories. Something we didn't touch on was our agents. I showed you a little bit of the assistant sidebar and how teams use that, but we also have agents that run in the background, which Maayan is an expert on, that can actually look at your user stories and write requirements for you, or make updates to requirements based on a user story. So it's a very flexible platform that allows teams to do exactly what this question suggests: continue to work the way you're working, while we help you create the evidence that you need, pulling all the relevant information you need into that requirements document.
Maayan Shvo: This was great. Thank you so much for a great demo and for being a wonderful co-host.
Bailey Canter: Yeah. Absolutely. And of course, if anybody's interested in doing a deeper dive and talking more about the key principles we touched on today, you can set up time. My team would be happy to walk you through the platform and give a dedicated demo. So thank you, everyone, for attending. We really appreciate it.