How do you change an aging application without losing the business knowledge buried inside it? On Tech Talks Daily, I'm joined by Veli Pehlivanov, co-founder and CTO of Resolute Software. We talk about systems that still do valuable work but have become difficult to change, particularly when some of the rules live in the heads of a few experienced employees rather than in the documentation.

Veli explains where his team finds AI useful: reading unfamiliar code, tracing dependencies, generating tests, and helping with well-defined changes. He also explains why they check those conclusions against conventional analysis tools, runtime evidence, and conversations with domain experts. Code that looks correct can still do the wrong job. Understanding what a system does is a different task from deciding which behavior the business needs to preserve.
We also discuss why moving an application onto a newer framework doesn't necessarily make it easier to maintain. Veli describes an incremental approach in which old and new components can work alongside each other while teams decide what to keep, replace, or buy. The questions become more cautious around areas such as financial operations, sensitive data, and access controls, where a small mistake can affect people well beyond the development team.
For leaders assessing the return on this work, we look beyond lines of code and test counts to changes the business can see: shorter delivery times, fewer defects, lower ownership costs, or a capability the old system couldn't support. We also talk about counting the cost of validation and rework when deciding whether AI saved time. Which application would you modernize first, and how would you know the result was better for the people using it? Share your thoughts with me.
Useful Links

[00:00:04] How do you modernize an application when some of the rules that keep the business running every single day were never written down? Well, today here on Tech Talks Daily, I'm going to be joined by the co-founder and CTO of Resolute Software. And I suspect plenty of listeners recognize the application nobody wants to touch because it still does something that the business depends on somewhere.
[00:00:31] And AI, yes, it might be able to help a team read unfamiliar code and trace dependencies. But it also leaves a slightly harder question. Does anyone know why it works that way? Well, my guest today will talk about using AI to speed up discovery, but also while checking its conclusions against code, tests and people who understand the business.
[00:00:57] And we will also discuss today why moving to a newer framework could leave the old problems intact with the wrong focus and understand which decisions experienced engineers should be keeping right now and how to measure success when producing more code. Tells you very little about whether the business can do anything better or not.
[00:01:21] Got lots of useful information and guidance in this one. So please join me in welcoming my guests onto the podcast now. So a massive warm welcome to the show. Can you tell everyone listening a little about who you are and what you do? Yes. Hi, Neil. Thank you for having me. My name is Veli. I'm co-founder and chief technology officer at Resolute Software.
[00:01:45] My background is in software engineering, particularly enterprise software, systems architecture and also engineering leadership and scaling up tech organizations. Before co-founding Resolute Software in 2018, I helped develop Telerik's web component products and later also led a large engineering organization at Progress Software and was responsible for the company's web component to the company's web component.
[00:02:11] technology portfolio at a global scale. That included Kinvay platform for enterprise application development and also NativeScript for cross-platform mobile application development using JavaScript. At Resolute, our team modernizes software applications, particularly in regulated industries and really business critical software that requires special care and special engineering practices.
[00:02:37] We also help build new digital products and adopt AI in practical production-ready ways. We have a senior-led engineering team, a lot of senior expertise in-house with which we deliver full-cycle applications, which means we cover the entire software delivery lifecycle from UX UI design through development, testing, deployment, and then, of course, operations and support.
[00:03:03] Our focus, particularly in the AI space, is combining AI-first engineering with decades of software development experience to deliver better outcomes, basically, for our clients and also faster. Our many successfully delivered projects and our expert team has brought us a few awards over the years. We're proud owners of the 2026 Gold Stevie Award for operational excellence in healthcare in particular,
[00:03:32] and then also the 2024 Web Excellence Award and also the 2023 Company to Watch Award by Deloitte, recognizing Resolute's outstanding growth potential in the technology consulting space. Wow, an incredibly exciting time for you. And I'm really appreciative of how you've taken the time out of your busy day to sit down with me today. And there's a lot I want to talk with you about, and I must admit you had me at modernizing critical infrastructure,
[00:03:58] because there is so much hype around at the moment around all things, not just AI, but, of course, agentic AI and agents. And it seems very often that we just keep piling more and more new tech on old tech. And as a result, we're seeing a huge rise in technical debt. And I think we're reaching a point where something needs to be done about that technical debt. And legacy modernization has been almost forcing businesses now to choose between speed, cost and indeed quality.
[00:04:28] So I'm curious, from what you're seeing and hearing out there with customers all over the world, why has that trade-off proved so difficult to break? Yeah, and your observations are spot on. I would say from our experience, software modernization is not simply about rewriting code. You have to preserve years of accumulated business knowledge or technology knowledge.
[00:04:50] And this is often embedded in the undocumented rules in the workforce, in tribal knowledge, in the legacy engineering team. And it's very elusive sometimes or really slowly fading away with just regular employee attrition. So what characterizes the legacy in this particular context is that it makes it difficult for businesses to produce new value
[00:05:16] or makes it extremely slow, especially in the rapid development of AI and conversely, all technology in software. Legacy is tightly coupled, typically, in terms of outdated frameworks, complex integrations. And every one of these legacy characteristics really make it tough to iterate quickly. Particularly in regulated industries, there is a huge problem with not just the legacy technology,
[00:05:43] but also in the fact that speed of delivery alone is not enough. It's worthless in its own right if it breaks compliance or produces legal risk. So what we've done over the years in the technology space, the so-called traditional software modernization, this has always been heavy on manual labor, manual discovery, analysis and development, and of course, very extensive manual validation of correctness and compliance.
[00:06:12] Increasing speed typically required increasing capacity or adding more staff or risking more or taking more risk in general. AI changes this economics now. It accelerates labor-intensive engineering tasks, however, only up to a certain degree where architectural complexity and risk still remain for humans to solve.
[00:06:39] And I suspect if I was to have a look inside every listener's organization that are listening and watching us today, they will have in their workplace an app that is no longer supported, that departments simply won't let go because they still think it's critical. And also there will be a server somewhere that nobody quite knows what it does, but they don't touch it. I've got to ask though, with so much at stake here, where is AI producing real measurable gains in modernization projects today?
[00:07:09] Because looking after that legacy technical debt there is something that people don't see value in. So what are you seeing and where are expectations maybe also running ahead of what the technology can reliably deliver? Because we're also seeing a lot of big promises out there, right? Certainly. And we see both observations to hold through very much. So some of the strongest gains that we observe in the age of AI is that now things related to code-based exploration
[00:07:38] and really the analysis of the legacy technology is facilitated through AI very successfully. And it's much faster than before. Things like code-level complexity, dependency analysis, test generation, and testing in general is very much up for grabs in AI in terms of capability. Repetitive refactoring and scaffolding, so the easy ways of adding new code to your system
[00:08:06] is also very well facilitated by AI. It can dramatically reduce the time needed to understand unfamiliar code, which is more important. And also, of course, implement well-defined transformations, things that may not be very complex but more time-consuming, or that may have to follow already existing structure and conventions that are well documented. For these cases, AI is perfect.
[00:08:32] And there's no denying that any team, an engineer, a meeting to incorporate AI nowadays in their engineering work is really missing out a lot on opportunity and speed and really competitiveness. Now, at the same time, however, we certainly see where the expectations for AI really exceed the reality or exceed the capability of the systems that are at hand today. There is one aspect that really does not hold true,
[00:09:02] and this is probably the most well-established expectation that AI equals autonomous, independent work throughout, which certainly does not seem to be the case from today's perspective. Undocumented enterprise systems, particularly where business behavior is implicit or poorly understood, are very, very much still not within the capability of AI to fully grasp and execute on independently.
[00:09:32] So the best of both worlds is when you can combine both. AI-generated code can be syntactically correct, yet functionally wrong. You need the human judgment there. Faster production code does not equal faster delivery times, as we see. Actually, the whole idea of moving fast now in the age of AI is transforming significantly since before AI,
[00:09:59] because now speed is not the problem in itself. We have more and more code produced, but whether we have more quality code or better results in the end is a different question. And we will have many people listening that are focusing on leveraging AI to deliver shiny new things, new projects, and bringing new things into the organization. But today, I'd love to look on the other side here and talk about how AI is helping teams understand
[00:10:27] things like undocumented code, dependencies, business rules, etc., all without creating false confidence in incomplete analysis. It's a huge task, or it used to be a huge task, not so much now with the help of AI, but tell me a little bit more about what you're seeing here and how this is perfect for AI. Yeah, certainly. It remains a huge task, but it's now much better facilitated with AI, especially if you plug it into the right engineering processes.
[00:10:56] Over the years at Resolute, we have found our own working formula for this. We treat AI as a discovery accelerator above anything else. It's not an authoritative source of truth for us, which is very important because we combine the AI analysis and inference that it can provide quickly for us with traditional, conventional, but deterministic tools for, let's say, static code analysis, dependency analysis, runtime telemetry, database,
[00:11:26] and data inspection in general, and also for inspecting existing tests and inferring acceptance criteria or really expected usages from the system. But we also combine this with a lot of typical engineering judgment and also a strict SDLC process that also includes a lot of interviews with domain experts. That still remains probably one of the most authoritative source of truth for what the system is and should become.
[00:11:53] So we need to distinguish what AI can demonstrate from source code versus what it infers about business intent, which is not the same thing. We need to make sure that what AI tells us is verifiable and we can accept it as a fact or as truth versus inferred and really concluded from its inference capability but should not be taken as a blank slate.
[00:12:19] So this also means that we require the traceability, points in code, configuration, database structure, everything that the AI can pinpoint for us that proves, that provides the evidence for the conclusion that it makes. And when you learn to use it or to incorporate it in your analysis and architecture procedures in this way, you really build a verified inventory of system capabilities.
[00:12:45] It's not just a hunch, it's not really tribal knowledge anymore, it's not implicit knowledge in the organization because you document it before you get to the next step of system architecture and overall modernization conclusions. And these are all steps that AI can help but should not be the sole judge. So in essence, AI can help us discover what the code is, but it cannot tell us why the business needs it to be this way.
[00:13:14] Anyone that scrolled down their news feed this year would have come across Vibe Coding, hit the headlines last year, even bigger now. And of course, faster code generation will immediately sound incredibly attractive right now. But what new review, testing and governance work, what does this create elsewhere in the program? Because we see the Vibe Coding headlines, faster code generation headlines, but there's a lot more going on behind that too, right?
[00:13:41] Certainly. A couple minutes ago, I mentioned that the quantity metrics in our industry are changing rapidly because now writing lots of code is not a performance metric anymore. It actually could be the opposite. More code equaling more risk. It could be the negative outcome for the same metric that we were observing a few years back.
[00:14:07] There's a couple of interesting surveys that tell a very revealing story. The 2025 Stack Overflow Developer Survey shows that about 85% of developers either already use or are planning to use AI in their development work. Yet at the same time, there is a survey produced by Veracode, a security analysis platform for source code.
[00:14:31] And in 2026, Veracode brings up a report that says about 45% of AI-generated code ships with a security flow in production. This is a major trend. Everybody's using AI. However, AI-generated code is not getting more secure. It's actually getting less secure. This means that really the quantity of code, the size of the code written,
[00:14:59] is inversely proportional to whatever metric of quality that we have, unless we do something about it. So the AI-generated changes in particular need a lot of scrutiny. Why? Because we may have a lot of regressions, we may have security vulnerabilities and unnecessary complexity that AI now knows nothing about. And it's up to a proper human judgment to decide and fix. Importantly, verification.
[00:15:28] Whatever AI guardrails or procedures we establish for verifying the correctness of AI-produced software, these should be standards-based on one hand, but also repeatable and turn into a team or organizational skill. What we see sometimes is a good judgment demonstrated by a single engineer in the team or some bureaucratic box-ticking exercise incorporated by organizations
[00:15:54] that need to verify that something has been checked from the AI-produced work. These are not enough. We need to turn this into really a repeatable, systematic, standards-based quality verifications for anything that AI produces, specifically for long-running legacy systems that have piled up a lot of expectations, a lot of capabilities, and also a lot of things to preserve exactly right with zero regression tolerance.
[00:16:22] So in summary, I would say code is cheap to produce now, but the quality and the ability to verify that quality is what is valuable today. Do you need AI agents that you can trust? Well, with an AI data layer providing real-time connection within your data platforms, you can trust your agents to provide accurate solutions. So scale your business by trusting your agentic AI accurately getting the work done for you.
[00:16:52] Trust its capabilities with Denodo. And you can do that by simply visiting denodo.com to learn more. And for leaders listening to our conversation today, how should they be deciding which of their applications or part of their code base are suitable for AI-assisted modernization and which will require a much more cautious approach? And you mentioned how you do work with regulated industries as well. I'm curious on the different approaches that you're seeing here, especially for people listening.
[00:17:23] Yes. At Resolute Software, we have delivered a few dozens of modernization projects alone, and I'm not even counting the end-to-end delivery projects that most of these continue with. So we have come up with our own little box of skills and repeatable practices that I can share. First of all, we start with a risk-based approach to our modernization assessment.
[00:17:47] We do not use a set of blanket decisions or cookie cutter type of approach for all kinds of legacy applications. This also means that we do not say use AI everywhere and by all means, because it's very much context-specific and also risk-specific. So what we do is we evaluate the business impact and the architectural complexity of each major technical layer in the system and or each component even in the system.
[00:18:17] This gives us a good outline of what are the critical system components or subsystems that we need to have a different degree of tolerance for AI-generated fault, right? So we pick strong early modernization candidates in this list. Let's say these could be like isolated components, well-defined APIs, well-tested and documented system capabilities that we can be slightly more liberal about using AI in those
[00:18:46] to demonstrate certain transformation or modern approaches in the overall solution. We specifically spend more caution for financial operations, healthcare data and workforce, and really authorization and authentication logic. And this is not just for regulated industries. Every specific application that we deal with has some non-negotiables in terms of business outcome, system correctness,
[00:19:16] and really the fault tolerance that we have in these subsystems. And these are layers that we spend extra care in and are specifically very skeptical in incorporating AI without understanding what exactly will AI technology do for us there, and where does human judgment come in? When we start really mapping out the modernization,
[00:19:43] the modern system architecture, we always have an incremental approach in this. Rarely can a legacy system, and even in a large corporation, that can afford the time and budget spent, but rarely do these have really one clean-cut migration step in time or point in time between the legacy and the new application. Usually, it's an incremental adoption of new technology, where we allow the legacy and the modern components to coexist,
[00:20:12] sometimes for a significant amount of time, in terms of years even. Martin Fowler, the legendary software engineer and author, calls this the Strangler-Fick pattern. And this characterizes our work very well, because we always try to come up with a solution that creates minimum disruption in the legacy, coexists the old and the new, and then gradually replaces the old with the new instead of one big bang event.
[00:20:40] There's additional steps here that I can elaborate more on. Yeah, please. Most of the times, we need to make some impactful technical decisions at the component or subsystem layer. These vary among whether we preserve and re-host the legacy with minimal changes. Maybe it's too valuable or too complex to consider modernizing at this point. Maybe it's about data compatibility and things that need to be preserved in terms of the data and the system being backwards compatible.
[00:21:11] Sometimes these subsystems could be refactored, or they could be re-architected completely and replaced eventually. This replacement could be done with in-house development, but also with off-the-shelf technologies that are now immediately available. These are some of the technology decisions that our consultants and architects have to make basically daily. And you can see that there's really no one-size-fits-all type of an approach here.
[00:21:37] So the right question isn't where AI can modernize the system. It's which parts can be modernized safely versus really take precaution here. And also we need to do it profitably and with measurable confidence. And I'm curious, from everything that you're seeing and hearing here, what is it that is preventing organizations from moving its existing technical debt into a newer stack and calling that project a success?
[00:22:05] It seems such a sensible approach, but something's holding it back. What are the bottlenecks that you're seeing here? A lot of teams think that upgrading from an old version of their framework to a new one, a typical example of a technology upgrade, is the same thing as a software modernization. Most of the times it's not. Software modernization is about preserving variable logic,
[00:22:30] but challenging outdated programming patterns, design paradigms, assumptions, unnecessary dependencies, and really opening up the system for a whole lot of new possibilities that should no longer cost a fortune and take a humongous amount of time to deliver in the legacy. So it has a very practical business target to achieve, not just a technology or a technical target.
[00:22:56] A lot of businesses use modernization to approve a set of non-functional requirements, like separation of concerns or unnecessary dependencies or modularity, API boundaries, automated testing, really the characteristics of a maintainable system in the long term. But most importantly, based on our practice, we see a very practical set of functional requirements that drive software modernization.
[00:23:24] And these are typically around supporting new types of users, additional devices, screen sizes, and form factors, really opening up new usage possibilities, enhance new markets and new user bases for a more competitive product. So in this realm, success really means the resulting system is easier to maintain. It's easier to extend and use, but it's also more secure to operate,
[00:23:50] which means that it's not simply running on a new version of the framework, but ultimately a modern system that opens up new possibilities for the business without breaking the bank. We've spoke a lot today around what leaders should be doing, how they should have different approaches, but I'd like to bring the techies listening into this conversation. Where must those experienced engineers, those architects, where should they be retaining decision-making authority,
[00:24:17] even when AI can produce an answer so much faster? Where do you see their roles continue to play? I would say, based on our experience and really, our consulting practice typically results in very successfully defended system architectures that most of them end up in long-term technology investments for multi-year projects after that. So we know they work at least most of the times.
[00:24:44] I would say there's two categories of technology decisions that we insist our consultants preserve, no matter the degree of AI adoption in whether the modernization assessment or the ongoing software delivery lifecycle after that. One, I would say, is the system architecture level decisions. So things like system boundaries, subsystems and componentization, coupling and dependencies, data flow and data architecture,
[00:25:14] and really the application security, everything around application security, should be based on really expert judgment. Of course, it's facilitated by AI, but the judgment is really on the architect to defend, based on the standards every time, and to preserve. In addition to the system architecture, I would say there's a set of business-critical behavior-related decisions
[00:25:38] that we would like to really be able to defend and propose the definitive answer to. These typically revolve around understanding the domain model. Yes, AI can help us, but it's really up to a human tool to judge in the end. Resolving missing or ambiguous requirements. Almost every project that we have dealt with, regardless of the state of its development or maintenance,
[00:26:04] comes with a pile of either poorly understood or completely missing requirements that we need to oftentimes retrofit in the legacy. So I would consider this to be one of the tough challenges for AI to solve independently, and it's almost always an expert-level decision that is proposed by our team. And of course, keep versus replace, right? The most straightforward of decisions.
[00:26:33] In the age where we have accelerated delivery of every kind of software, building in-house is no longer the norm. It should actually be a very critical, really, we should take a very critical look at any kind of in-house build versus buy decision or even partner strategically or product-wise because there's just a lot of options out there.
[00:27:00] And chances that something is completely unique to a certain application or business in a domain are very slim and getting slimmer. This means that there's a real chance that something that already exists is the better solution to anything that the engineering team can build, at least in the short term, because you can get it immediately in terms of complete functionality. So these type of decisions we try to keep in-house,
[00:27:28] meaning in the expert human judgment of our team. And AI is a valuable helper and assistant tool for this, but not the source of truth. It's so interesting you say that because I think at the moment, the rise of vibe coding, which we've already discussed, created that big rumor of the Saspocalypse as an engineer said, well, we don't need to go anywhere else to build a program. We can just code it ourselves. We'll bring it in-house. But of course, there's so many different risks in doing that.
[00:27:56] And even if you do manage to master and build something that is designed perfectly for your organization, the upkeep, the constant patching, keeping it updated, these are things that are often neglected, right? Certainly so. And it's going to get worse and worse unless we have a very structured and well-defined, well-regulated, well-controlled, I would say, process for how we can use AI in this. Because what happens is we are accelerating the pace of delivery,
[00:28:26] not necessarily accelerating the quality of delivery. Now we need to make quality run ahead of the pace, which is almost impossible to do without the proper, really human judgment and systems in place to enforce this human judgment. Otherwise, any type of success that you get with purely AI-generated product is really incidental more than organizational. And other big challenges out there that we've seen,
[00:28:53] especially with the increased focus on return on investment, is metrics, knowing what to measure and how to justify or prove real value being put into the organization through AI. And things like developer productivity, that might be easy to measure, for example, but it doesn't actually prove that the modernization has worked. So what businesses and operational measures are you finding provide that more honest picture that leaders are looking for right now?
[00:29:22] Yeah, metrics of success is a hot topic for us consultants and engineers in general because it's so problematic in the age of AI because none of the old metrics work in terms of at least measuring developer productivity, like measuring lines of code written or really size of project or even number of tests. One traditional metric that used to be very strongly defendable before AI
[00:29:50] was the so-called coverage, source code coverage in your tests. And everybody was bragging about 90 plus percent software coverage in their tests. Well, guess what? AI can now come standard with 100% code coverage and the development team could still tell you that they have very little confidence in the product that they're building, which is an interesting observation
[00:30:16] because clearly the old metrics that we have been measuring and working to optimize because you always get what you measure, right, are no longer working. So in our team at Resolute, we have a slightly more business-oriented mode of measuring success. It really comes down to the business outcomes that we either directly enable or facilitate to make happen. Things like faster time to market, lower total cost of ownership,
[00:30:46] improved customer experience, or ability to launch new capabilities and new products that were even previously blocked in the legacy application. These are all measurable outcomes, still measurable, still not within the realm of just imaginative thinking or speculative objective guessing, but they are now also much more telling for the overall impact of the engineering work that we do. And of course,
[00:31:14] we still have the typical engineering outcomes, but we no longer measure line of code or number of tests as exemplary. Much more interesting for us are now code quality metrics like testing, like defect rate, testing meaning not test coverage per se, but the confidence of our test professionals that the system really is working as acceptance criteria required it to. And also deployment frequency
[00:31:42] and lead time for changes. This is very important because we always consider AI to provide a very low-hanging fruit with the automation of things like testing and deployment. No team now has really the justification to say we cannot deploy fast enough. In the age of AI, even legacy applications could be made to deploy fast enough. It's completely automatable and it's typically a relatively low complexity task
[00:32:12] that engineers have high confidence that AI can successfully achieve. So these become also important metrics for us. And then ultimately in the AI economics, if we take a step back, we measure the costs per successfully completed engineering task, including validation and rework, not just tokens consumed or AI bills or code generated. So the ultimate measure of modernization
[00:32:41] isn't how quickly we wrote the system, it's how much faster the business can now operate. And for people listening, we're recording this at the end of 2026. A lot of people are going to be focusing on life in 2027. Now, what excites you about next year? What's your big focus going to be at Resolute? Anything you can share about the road ahead and how you see it? Yeah, certainly.
[00:33:09] It's going to be an exciting 2027 for Resolute for sure. Because for the last two years with the rapid development in AI, we think that we have laid a very solid foundation for scaling AI operations for our customers. This does not only mean adopting AI for software modernization, but really responsibly and successfully adopting AI at scale
[00:33:35] for any kind of business outcome making process for our clients. As software consultants, we do not just work with technology, we also work with the business. We often analyze business processes and really human processes in those businesses. When we produce things in manufacturing, we get down to the production floor and really the behavior of the operators that need to use the software for getting, you know, to get more productive. So we think there's AI potential
[00:34:05] beyond just the AI capabilities of the software. Yes, we already use it extensively in our software delivery lifecycle. And we can also help train our clients' engineering teams to successfully adopt this. And this is probably easier said than done in regulated environments that have much more non-technical requirements than simply technical. But we think that we've very successfully implemented a few of those there as well.
[00:34:33] But more importantly, in 2027, we expect that we will be part of the broadly encompassing adoption of AI in the labor force in general, not just through software, but also through insight, also through the general operating models that will now more and more rely on AI. Where we believe Resolut fits in this picture is to make AI outcomes reliable and dependable.
[00:35:02] AI is a non-deterministic technology, meaning that when it is right 99% of the time, you should exactly know the 1% where it's wrong. And this is really the challenge to get from 90% or 90 plus percent to 100. We believe we can achieve this and we already demonstrated for our clients through structured processes like correctness verification, source of truth,
[00:35:32] human judgment and control, and also the organizational skill required to adopt AI beyond just within a simple or single project. And this is how I see Resolut scaling up to go beyond just software architecture, but also organizational architecture and consulting in the age of AI. And I think that is a powerful and thought-provoking moment to finish on. And for anybody listening
[00:35:59] that are interested in focusing on agile, continuous and your predictable delivery of solutions to help them expand their digital footprint and realize some of their dreams around modernization there, where can they find you and indeed your team online and find more information about the kind of work that you're doing and the announcements coming out, etc. Where should they go? Yeah, for anyone interested, they're free to visit our resolutesoftware.com website to discover more about our services,
[00:36:29] find engineering insights and client success stories. We tell every success story for our clients when it's not explicitly off the limits for us to tell about the story. Sometimes it is because we work in really regulated industries with increased secrecy, I would say. But most of the times we have very interesting stories to tell and we try to tell them every time on our website. And also social media.
[00:36:58] Myself and our team members are all on LinkedIn. You can easily find us there, learn more about our .NET modernization and advanced AI engineering practices. And let's stay in touch. Yeah, 100%. I'll be adding links to everything. The website, social channels, your LinkedIn, etc. I'd urge people listening. If anything resonated with you today, please go click on some of those links. Find out a little bit more information. You don't have to carry on the way you always have done
[00:37:27] and building that technical debt up. There are very easier ways, especially with the right partner in place of modernizing your infrastructure. So I'd be interested in people's response as well, the challenges that they're having. So please feedback to me at techtalksnetwork.com too. But more than anything, thank you, Veli, for coming on here, talking about this as a language we can all understand and bringing it to life with some real world examples. Really appreciate your time today. Thank you for hosting me, Neil. It's been a pleasure. Appreciate it.
[00:37:57] I keep coming back to my guest's distinction today between finding out what code does and understand why the business still needs to work that way. An AI tool can give a team a useful head start, but someone still has to check whether an unusual rule is a mistake or the reason that an important process works. And I also liked this test for modernization. Can the business do something it couldn't do before? And is the resulting system
[00:38:26] easier to maintain and change? And it's worth remembering that a new framework alone won't answer that. But for a team deciding where to start, one small, well-understood component offers a way to learn without betting the whole application on a single migration. So you will find Resolute's website and Vali's LinkedIn in the show notes. And if you'd like to continue the conversation, please check that out.
[00:38:55] But before you do, I question for you a bit of homework. Which application inside your business would you modernize first if you could? And whose knowledge would you want in the room before considering changing it? Lots to think about there. You can get hold of me at techtalksnetwork.com. Please go check that out. Got lots going on over there as well over the next few weeks. I will reveal no more for now. But thanks for listening as always.
[00:39:23] And I'll be back in your podcast feed tomorrow. Bye for now.

