Transcript#
This transcript was generated automatically and may contain errors.
Hello, we're here to talk today about Compliance Without Friction and how the Posit Team platform helps you master that persistent analysis lifecycle and make everything a little bit easier along the way.
My agenda today is pretty simple. I'm going to show how we help organizations like yours using Posit Team. But before we dive in, a little context on where our perspective comes from.
Posit is the company behind RStudio, which is a tool used by millions, and it's along with the open source projects like Shiny, the Tidyverse, and Quarto. Everything we build is accessible to everyone, regardless of economic means. As in data science, we believe that being able to reproduce and critique others' work is essential for real progress.
So what does that really mean for you? That means that the barrier to entry today for you is zero in this process. You have free access for life to RStudio, to Positron, with the option to expand. And that's where it's important to share that we also build the professional grade tools as well, used at more than 10,000 organizations.
And after more than a decade working with teams across life sciences, banking, government, and beyond, we've seen up close what makes data science really succeed. And also, we've understood a little bit of what gets in the way. And honestly, the biggest challenges usually aren't the models or the analysis. They're the environments that the teams are working in.
Most importantly, Posit isn't selling you a suite of products. We're really inviting you into an ecosystem where the free tier is already substantial and the paid tier removes a lot of the friction at exactly the right points where your organization tends to need it most.
Put more simply, we're the only open source data science company who has publicly committed to never selling or going public in order to ensure that our mission is uncompromised. And there's a lot of companies in this space. And many of them are chasing the next infusion of venture capital or the next major acquisition or the next IPO. And that's never been our goal, frankly, and it never will be.
Put more simply, we're the only open source data science company who has publicly committed to never selling or going public in order to ensure that our mission is uncompromised.
Furthermore, we reinvest in that public mission every day. And yes, in this case, free truly means free.
The Posit Team toolchain
So why is that important? Well, our professional data science tool chain called the Posit team addresses the typical three challenges in a data science workflow.
Posit Workbench provides a secure and scalable development environment for our Python users who want to work and write in RStudio, Jupyter, VS Code, or Positron. Posit Connect enables sharing those insights by facilitating quick and easy deployment of all of many open source frameworks, things like Shiny, Dash, Streamlit, APIs, and so much more. Posit Package Manager provides the tools you need to host packages inside your firewall and monitor things like system dependencies, license agreements, et cetera. Package Manager really provides that governance piece.
And I'm going to quickly demonstrate how all of this works for you as we go through this process.
The persistent analysis challenge
Now, it's important to be said, our customers face challenges similar to those in your organization and dealing with complex analytics, data science challenges are our specialty. So let me walk you through some real life examples as we go through this process.
One thing that we often hear is this. So imagine this, you're juggling projects, deadlines are tight, and then an email hits. Management wants last year's analysis redone, same data, new assumptions, maybe change data, we don't really know, and they want it fast. For analysts and data scientists, that's really just the job.
These requests come with a lot of urgency, not a lot of extra time, and that's usually when the scramble begins. You start digging for old code, you hope the environment still works, you try to remember what assumptions you used, and you cross your fingers that the results are even reproducible, like they were six months, 12 months, you know, and so on ago. It's frustrating, frankly, and it really pulls you away from the real analysis.
And so we asked the question today, what if that whole cycle disappeared? What if revisiting an analysis was quick and painless? You open the project, you see exactly what was done, you update the assumptions, you deliver results all in minutes.
And that's really what I'm here to talk about today is Posit's modern ecosystem that makes all that possible with clarity, reproducibility, and trust. For analysts, that means less time wrestling legacy code, more time generating insights for managers. It really means that they can trust and defend the content that's being produced. And for organizations, frankly, it means workflows built on transparency and efficiency. And so to that, I say that Posit doesn't just speed things up, it makes the work better in this instance.
So let's walk through this scenario together. I'll show you how Posit's platform from Workbench to Positron and Databot and Positron Assistant as well as a little bit on Connect, how we really take all that and transform a simple request into a rapid traceable deployment cycle. And we'll start where most of us begin in the Workbench. That's the familiar environment that anchors the entire ecosystem.
Posit Workbench overview
Now I talked about starting in Workbench and just as a refresher, Workbench is where the development happens. This is your IDEs, your development environments. Posit Connect is the deploy side and Posit Package Manager is that governance piece that we talked about.
So we begin looking at these different pieces here and it's important to note that all three are centrally hosted in your Linux environment and provide a no-download, no-plugin web-based environment in which you can work.
If we start out by clicking Posit Workbench, we say, all right, here we are in Posit Workbench. This is an integrated development environment designed to support reproducible analyses, scalable models and collaborative workflows. And you'll notice something familiar right away.
When we start looking at the sessions and a session being an opportunity to open up a development environment, full-fledged development environment for use on your web browser, you'll notice something familiar right away. RStudio and VS Code are both here. That's something that we see a lot of requests for and people find that most common. That's by design. Workbench doesn't replace the tools that you already use. It really brings them together so you can stay in the environment that you're comfortable with.
And while you're benefiting from a more unified platform, you can choose from Jupyter Notebook, JupyterLab, as well as Positron Pro, our newest IDE, in a scalable environment in addition to the regular ones that you've used in the past, which is RStudio and VS Code, as we mentioned.
We can start as many of these sessions as we like, and we have flexibility around how we open those sessions. But if you remember in this project, we talked about opening an old project. It could be a year ago. Now I've got this listed as 104 days ago. It could just as easily be a year ago.
So as we open RStudio and we review our old project, we see through RStudio being consistent, it's a great sense of continuity. We're able to revisit the work from last year, and you don't have to reorient yourself. You don't have to rebuild your setup. You open Workbench. It feels familiar. The familiarity itself lowers friction, helps you get back into the analysis quickly. But you're doing it on an infrastructure that provides scalability and adaptability.
We're able to go through and look at our old code. We see all of our old content that familiar RStudio environment is in place. But when we look at it, we say Workbench itself, not just that single IDE, goes beyond just the familiar editors. It brings reproducibility and collaboration into the workflow itself. Projects are backed by version control, both in Git here, as well as in Positron and working in VS Code. You've got dependency management, shared environments, and that really means that teammates can pick up where you left off or you can trust that everyone is working from a consistent setup. It helps eliminate those ideas of, well, it worked on my machine.
And for managers, it leads to an idea of traceability. We can go in, run an application. We can see that it's consistent and that type of consistency is often hard to achieve. With a fully working project in an online version of RStudio, it's a practical way to support governance and transparency without adding a whole lot of extra steps to the team's workflow.
The idea is pretty simple. Workbench lets you keep using the tools you already rely on, but within a more integrated and reproducible setup. It's really easy for the base layer, for everything else in the Posit ecosystem, and with that foundation in place, we can take the next step here into Positron in just a second. That's the evolution of the IDE where, in my opinion, intelligence and governance really start to come together into everyday productivity.
Introducing Positron
So now, as I mentioned before, we have multiple sessions in place. This could just as easily be Jupyter Notebook sessions, other RStudio sessions, as you see, R and Python content, but in this case, I've got a Positron Pro session. As I step into this, I'm going to be able to come into here and I'm going to be able to open that same project, that same project that I had just a moment ago that I was looking at, and RStudio is open here in the Positron workspace.
The really cool part of this is, it's Posit's next generation IDE. It brings together a familiar coding environment with an intelligent assistant and governance aware workflows, and you can think of it as the next evolution of RStudio, and it's built for modern analyst data scientist work, where speed, reproducibility, and compliance are part of the everyday reality.
So a couple of things to point out, as we come into here, there's certainly, if we want to see something like this, and we look at plots and variables and other pieces, we get that four panel familiar feeling of RStudio, but yet for the VS Code people, we see that we're in a similar space and it feels familiar to the VS Code that we know and love. We have the ability to come into here and look at different interpreters, working with both different versions of R, different versions of Python, all in the same space.
And finally, when we start looking at the other VS Code pieces, there's the extensibility. We're looking at the Explorer file, Explorer over here, very familiar from a VS Code standpoint, the source control integration, making it a little bit cleaner and easier, the extensibility of the extension marketplace, so we can provide R extensions as well as Python extensions into the space and expand the interfaces we see fit. Things like Positron Assistant that we're going to talk about here shortly, and OneClick Publishing that we'll come into here in just a moment.
When we kind of start out here, we're able to come into this space. We're able to come in and take that old project that we had, and we can just run the code. We can run the code itself, we can run the application, or I can just simply hit the button and we see that it kicks in.
Same thing, code is running here, it's over a year old, Positron keeps the same environment consistent and the dependencies managed. You're not spending a lot of time troubleshooting, you're getting the results right away. So you're back in looking at that same application that we looked at just a minute ago.
As I mentioned to you, it's really not just an IDE to me, and to others, it's more of an ecosystem. You get faster iteration cycles, you get built-in documentation support, you get compliance awareness woven into the workflow. And for analysts and data scientists, that really means that you can stay focused on the math, the modeling, the risk assessment, while Positron takes care of the underlying structure around governance and reproducibility.
So in this case, we're looking at the analysis that existed last year. It ran, it produced results, but now we really need to revisit it with some updated assumptions. And this is where Positron really starts to shine. It gives us the tools to revisit, refactor, and enhance the work without starting over. Instead of worrying about whether or not the environment still works, we can stay focused on the business problem.
Exploring data with Databot
So here we are, we've rerun the legacy code, we've confirmed everything works. So let's bring in Databot, Posit's AI-powered analyst, to help us take a little bit of a fresh look at the dataset and understand what's changed since last year.
By coming up here to the search bar and hitting show and run commands, I can open the Databot in the editor panel. Now, because of the time assumptions have shifted, new data may have been added and management wants to know what's changed. And instead of sitting here and digging through the dataset line by line, we can lean on Databot to help speed up that discovery process.
So what is it? Databot, as I indicated, is Posit's AI-powered analyst that works with you. It helps you profile your datasets and highlight patterns, anomalies, and shifts in the data. It really helps you speed up the early exploratory work so you can focus on the interpretation, the modeling, and any of the decisions that follow.
Just to give you a clean idea of what's happening, let me start the analysis while I continue to talk. So I'm going to type in here. So let's say load and explore the datasets from my slash data directory. And I'll ask it to highlight any anomalies and issues.
Now as I kick this off, it's looking for the dataset that's over here on the left-hand side. This could be flat files. It could be parquet files, JSON, CSV. It could also be database tables. So if you're connecting to a data source or you're connecting to a larger repository of some kind, you can go through and analyze those tables.
Now I know what you're probably thinking. A lot of people have said, hey, AI is inaccurate, or it's a little intimidating, or it takes a ton of expertise, or sometimes it makes things up and it hallucinates. And as you can see, it's going through and it's doing some work to find some of that original content, and it's trying to navigate through.
AI is going to go through and it's going to make mistakes if you use it the wrong way. But the way we're utilizing it, it's coming through and it's called what we call human in the loop. So we always have somebody in place.
The key idea is this. As you see the analysis occurring as we go through, there's a couple of things happening. First and foremost, the analyst is always in the loop. The data scientist is always in the loop. They're asking your permission to do things up front.
When we ask questions, we're not just looking for AI to spit out a magical answer. We're using it to help us write code that locally derives the answer. So when you shift the role from AI, from answer machine to analysis partner, everything changes a little bit. Accuracy goes up, transparency goes up, and suddenly these tools become genuinely useful, helping you turn days of work into hours.
So when you shift the role from AI, from answer machine to analysis partner, everything changes a little bit. Accuracy goes up, transparency goes up, and suddenly these tools become genuinely useful, helping you turn days of work into hours.
So you can see a number of things happening here, and you'll notice how quickly Databot is going through and surfacing the shape of the data. We immediately start to see where values are appearing, where things might be missing, where distributions have shifted, and where anomalies stand out. And the important part of this process is, this is the kind of work that usually takes hours, but here it's automated and reproducible, and it's transparent. It's writing code.
As you can see here, the code section is being highlighted. This is being run so that, one, it's transparent, two, it's reproducible so that you have it all in front of you. Databot is both writing the code to take action, making the work reusable, but it's also going to come down here, and in the end, it's going to give you a summarized result. It's a bit like having a junior analyst who never sleeps working with you, flagging the issues before they turn into problems. And for data scientists, that means less time on the exploratory grunt work and more time on interpretation, modeling, and decision making, as we highlight some of those things here.
It tells you what looks good. It gives you some suggestions on some additional things to look at. It's not replacing your expertise. In this case, it's amplifying it.
And as we go through some of the things that are here, it highlights some issues. We see that there are problems, and I can go through and say, okay, well, it's investigated some things. There's some initial values. There's a distribution plot that can be surfaced, explore the hypertension anomaly further, or we can examine 10 individuals with DTI ratios greater.
Data Bot, as it goes through this process, is helping me look at the data with fresh eyes. And instead of guessing what's changed, we can see it directly. New patterns, updated distributions and risk factors, and potential outliers flagged for review. And that clarity gives us confidence to move forward in the data.
So you'll see it's going through and it's continuing that analysis for me very transparently in this process. And it's helping me break out what are my data issues and my data points, and what are my distributions and content to see here.
Refactoring legacy code with Positron Assistant
With Data Bot's insights in hand, we're ready for the next step of reviewing and refactoring the legacy code. And that's where Positron Assistant comes in. But that's going to help us document, enhance, and modernize the analysis so it's not just functional but future proof.
Now that we've rerun last year's analysis and pulled out some fresh insights with Data Bot, we kind of hit a familiar challenge. Legacy code without documentation sitting in front of us. It might run, but it's often hard to interpret. And for data scientists, that's a problem because the transparency and reproducibility are essential. If you can't explain what the code's doing, it's tough to fully trust the results and the stakeholders frankly feel the same way.
So let's begin by understanding what the code is actually doing. And if we bring up Positron Assistant here, we'll note a couple things. We can see this here in both, as we saw in Data Bot in here, there's a couple different things. I can sit and ask what I want to ask questions of this code. I don't want to edit it just yet. I'm just going to ask for content up front. I can choose the models that I'm utilizing as part of this process. And furthermore, when I ask questions, they're being applied in context so that we see that the application is open here.
As it goes through this process, Assistant is going to break down the application section by section. It's going to summarize what each part of the code is doing. The opaque script suddenly becomes readable, not just for me, but understandable for colleagues, auditors, and anyone else who might revisit it later. We can ask for this to comment the code. We can use what used to feel like a black box and turn it into something that is now clearly explained and transparent.
This is not simply relegated to the sidelines, but it also offers you the ability to interact directly with the code itself, to ask direct questions about the content in the code, and do more along the way.
So as I scroll down, it's important to note, as I'm looking at some of the pieces here, I see that the application code is highlighted here. As I come in and I start to interact with the code and I highlight here, I'm able to see that contextually, this has changed the code to say, this is the current file context. We know that we're interacting with a certain number of lines.
It's going to use that in reference, and it's going to say, OK, looking at the highlighted section, specifically those lines, this is what this section does. This goes beyond documentation at this point in time. It's collaboration. I can start to ask for enhancements, like isolating high-value claims, or I can make quick modifications, and the Assistant integrates them cleanly. It keeps things reproducible and traceable, so that changes are consistent and easy to follow. Instead of manually rewriting the code, I can iterate quickly and confidently in this process.
So I'm going to do something else down here, and I'm going to change this from ask to edit. And it's going to say, it's going to end your current session, would you like to change the agent? I'm going to say yes, I do. I want to change that.
If you'll remember, I had two dropdowns on that initial first page. Now because I've changed this to edit, would you change the risk category to first page to radio buttons? It's going to go through, and it's going to look at the content on the screen. It's going through, and it's going to highlight the different sections. It's going to use that as a reference, and it's going to go through and try to apply this and make the modifications for me.
Now as it goes through and makes those edits, it highlights the sections for me and allows me to replace the individual sections, keep them, or undo those sections. As I hit keep, we're going to go through and quickly make that modification. So instead of spending hours deciphering old scripts, we end up with maintainable documented assets in minutes, and it sped up my entire process. I've been able to go through and modify the code, put in radio buttons, make the adjustments, and not just am I freeing up time for higher value analysis, it's also helping me preserve institutional knowledge. So work doesn't just disappear when people move on. I have a way and a means by which to go back and review.
Positron Assistant turns all of this undocumented legacy code into clear, maintainable, transparent assets. Code into Clear, Maintainable, Transparent Assets, taking that black box I talked about a minute ago and turns it into that glass box. And with that in place, we're really ready for the next step, deployment.
Deploying to Posit Connect
We've understood and updated our analysis, and now it's time to deliver it. So stakeholders don't want to dig through code. They want things that are accessible. They want things that are interactive that they can explore and trust, and that's where Posit Connect comes in. If you'll remember, we talked about it's the publishing hub that turns technical work into stakeholder-ready apps, dashboards, and reports.
So let's kick this off. We've set this up. It's configured in place. We have the project files that we're working with. We know what we're going to be publishing out. All we need to do at this point is just hit Deploy. We're deploying this out to Posit Connect, and it begins this process, and you're going to see a number of things that are happening down here.
Posit Connect is a huge piece of the puzzle. This deployment works from Positron, RStudio, VS Code, et cetera. It's the platform that lets data scientists share R and Python content, shiny apps, dashboards, APIs, reports, notebooks, with those business stakeholders that we were talking about without needing to involve IT in every deployment. It can be an IT-focused tool, but it doesn't have to be. It handles scheduling, access control, and environment management in one place, so teams can move from analysis to decision-ready output without friction, and it's a big thing for me is removing that friction. Essentially, I look at it as it's kind of that last mile between the code and the people who need the insights.
Now, when deploying Posit Connect, Positron bundles your entire environment up as you see it's doing down here. Package names, package versions, your R or Python version, your code, and then it creates that exact configuration in Posit Connect automatically, and you saw how fast that went through. Regardless of where you work, the deployment's unified. With one click, the updated app goes out live into Connect. No manual packaging, no server setup. The app shows up instantly, and it's ready to share.
Now, behind the scenes, one of the things that we didn't talk about too much up until now is that Posit Package Manager is keeping things reproducible. It's curated internal source packages that ensures that everyone on the team installs the same versions from the same place, which removes a huge amount of variability, so as we're moving content from here, where we're in our development environment, over to Posit Connect, it makes sure that those dependencies are locked, that environments stay consistent, and every run is traceable. That gives managers confidence, helps auditors verify results, and lets teams reproduce the work months or years later because its governance is built into the workflow, not bolted on afterwards.
One click, your app is updated live. It closes the loop between analysis and delivery, making sure that insights actually reach the people who need them, so let's now look at how to share and engage with the stakeholders directly inside of Connect, so delivery isn't just functional, it's smooth and intuitive.
We moved past something that's very important, and we see here, and we created a bundle. As I highlighted, there's a lot of importance to that, and we'll see this when we get into Posit Connect. The creation of that bundle means that, again, just to reiterate, we captured your full development environment that's here. Your space, your colleagues' spaces, other people who are developing. You take this, and we capture it all, and we move that over. Not just move it over, but restore it, so it's a perfect restoration of the environment exactly as it was here. We run that content. We validate that that deployment was moved correctly, and it matches up, and that now I have a single link, and I can click and move into Posit Connect.
Sharing and governing content in Connect
The real impact here is not just the deployment. That's only part of the story. You see that we moved this in. We see that we've changed this flow. The code has changed over here. We've done our data analysis. We've got this application out here. The real impact comes when we're sharing this, again, clear, governed, and easy to use, and it's not just about making something available. It's about making sure that it's usable, that it's trustworthy, and it's aligned with what the audience really needs.
If I need to move something in place, and I need to adjust, I can add descriptions. I can add thumbnails. I can make the app easier to find. It tells people what they're looking at, why it matters, and how to use it. A logo and a short description here aren't just decoration. They help the app feel polished and approachable.
As we look at some of the other settings, that bundle that I talked about, bundling gives you the ability to retain multiple versions in Posit Connect. So there's some built-in version control to it, not just the version control that you use through GitHub, GitLab, Bitbucket, Azure DevOps, et cetera. But this is version control that's built into the application. So if I need to time travel a little bit, I have the ability to do so through the application here, moving back and forth and selecting different versions. Potentially, I left too quick on a Friday. Maybe I made a mistake. Maybe there's an issue with the data, and we need to roll back. But I can activate those previous versions, view logs to make sure that the publishing was done okay, and even download that code if it's lost time.
Other things that come into play is access, and this is where access controls come in particularly valuable. Each application comes in with its own unique identifier, making this accessible. So you can see, you can govern who has access to the content and what content it is. I have this unique identifier that allows me to put it into an intranet website. I can put it into a web portal. I can put it into an email. I can send it out in some way, but I can also create that custom URL. That custom URL does a couple things. It makes sharing simple. Instead of sending a long, messy link, you can share something that's clean and memorable, and it closes the loop quickly and makes the app easy to reference later.
I also promised you some information about access control, and this is a spot where you can share confidently. Now in this instance, for your purposes, I've set up this application so it's accessible and shareable in the outside world. This is something here that I've set so that anyone can log in, no login required. You can choose exactly who can see the content, a team, a client, group, or the whole organization. It keeps sensitive work protected while still getting it to the right people.
The way that it does it, if you're asking that question up front, is you'll remember over here, we talked a little bit about coming into Posit Connect and the integration with your environment. That integration comes in the form of using your security infrastructure, Entra ID, Active Directory, SAML, LDAP, using something like Okta or two-factor authentication. You control that access because it's passed through into the application, and we're using it to secure the content, making sure that the data is also secured along the way.
Now for purposes of this, I'm not putting in any individual groups, or I'm not putting in any additional individuals that I might look to include along the way. I can make it as simple as giving people access so that they can come in, click a mouse, and get information, or they can come through and be contributors and help me monitor and publish additional content along the way. For purposes of this discussion, I'm sharing with anyone, and I'll share this link with you so that you can access this application and test it out.
Last but not least, things like usage content so that you can see who's visiting and how often people are coming through. And then, of course, there are some applications where you might need to change some of the environment variables, and I'm not going to go into too much detail today about this. But suffice it to say, if you needed to customize an application to account for that high-water mark first Monday of the month at 9 a.m. or the last quarter report, you can customize so that we can adapt accordingly.
Now, we run this application, and we see what's here. This is interactive for the end user. They can come down. They can make interactive suggestions. They click the application itself, make it as complex as you like.
The thing that I wanted to highlight is including something here called query chat. Query chat does a couple things. We try to plan for what the end user wants to see up front. We try to answer the questions that they might ask. But there's always something that comes after the fact. And query chat adds a layer of dynamic insight. Stakeholders don't just see static results. They can ask questions in plain English language and get data-driven answers. It turns the app from a report into a conversation.
In just a few minutes, we've gone from the requests from the stakeholder to content that's ready to be delivered again, with governance, that reproducibility, and clarity built in. And that is the strength of the Posit ecosystem. It delivers not just analysis, but confidence, transparency, and engagement.
Quarto reports and the full lifecycle
As we talked about at the top of the call, the content that's produced here is a broad range of content. There's that application that I just published. We have Shiny applications. We have R Markdown, Quarto documents, API content, integration with Databricks and Snowflake. We might have additional Quarto documents. I think I highlighted there, Jupyter Notebooks, Python content, Streamlit, and more. Gives you a broad range of content, all hosted on the same platform and easily accessible.
Now there's a lot more that we are just kind of skimming the surface on with Posit Connect, but it's important to highlight one additional thing. We published that interactive app right here that stakeholders can explore. They can ask questions with query chat to see results. And in a lot of these workflows, people need a formal report to go with the app, the actual application as well. And that's something that they can circulate, they can archive, or they can even reference offline. And this is where something like this, where I have a matching report comes into play.
This is a Quarto document, and this is where Quarto starts to help us do some pretty significant things. Looking at the data that was just displayed in that previous application, Quarto lets us generate polished documents directly from the same code and the data behind it. No copy and paste, no manual rework, just the same analysis presented as a clear narrative.
So here's a Quarto document summarizing the risk assessment data that we just saw. And in this document, you're going to see tables and charts pulled straight from the analysis. You're going to see narrative text explaining assumptions and methodology. And the nice part of this is you can schedule it to automatically update whenever the data or the code changes. And as you come through, you can see different things like key risk factors, and you can even include things like conclusions and summaries of findings so that people can do more interactive analysis. The report always stays in sync with the app, and you can schedule that to do so.
Quarto bridges the gap between interactive exploration and formal documentation. And stakeholders end up with both a dynamic app for discovery and a reproducible report for governance. And that combination really starts to build that confidence that we talked about. Managers know the numbers are consistent, auditors can trace the process, and the teams stay aligned altogether.
So in other words, Posit doesn't just help us deliver insights quickly. It makes sure that those insights are documented, reproducible, and as I said, stakeholder-ready in every format. And that really brings us full circle from request to analysis, to deployment, to reporting.
So as we step back and we look at the larger content, from the moment that the requests came in, we moved through the whole data science workflow together, revisiting legacy code, reanalyzing with Databot, summarizing with Positron Assistant, deploying in Connect, sharing with stakeholders. And in this case, each stage was faster, clearer, and more reproducible than the old scramble and patch approach that we had in the past. What used to feel chaotic becomes a structured and traceable cycle that delivers confidence as well as speed.
And for the analysts and data scientists, again, that means confidence in numbers. It means that every assumption is calculated and is documented and reproducible. And for managers, it means traceability and governance, results that they can stand behind.
So Posit's platform itself doesn't just speed things up. It raises the bar for trustworthiness and transparency across that entire data science lifecycle using all of these tools that we've seen here.
So Posit's platform itself doesn't just speed things up. It raises the bar for trustworthiness and transparency across that entire data science lifecycle using all of these tools that we've seen here.
So with that, I'm going to open up for questions and transition. So thank you.
