 doing at AccelTrad. AccelTrad is basically, I'll go high frequency trading company. So what I'm going to do now is talk briefly about the challenges we face in building and managing this kind of a setup. Hopefully some of the things that we face is going to be contrary to the advice we have heard today and that will probably make you think and reflect on it more. So what is the key challenge here? The system we are building needs to be able to, like between getting a packet on the network and processing and sending out the order, it has to do it in single digit microseconds. Single digit microseconds that changes everything that you know about building software. So like most systems that we've heard about at PEP scale and all that, like a request if it takes a few milliseconds, that's supposed to be good. But if you have to do something within a single digit microsecond, everything changes. You can't access disk, there's no scope for doing extra network hops, all those microservices stuff goes out of the door. No locks, no threads. Sometimes even the kernel gets in your way. So you need to use network stacks that run in the user space because the kernel overhead is too much. You need to use accelerated cards, pin, process to codes, a lot of stuff that you need to do to be able to achieve that kind of latency. And you need to do it at large scale also. Like you need to process about five billion ticks over seven, eight hours. So this is really challenging and a lot of the things that you know about building software changes dramatically when you build systems like this. And this is one aspect of it. The other aspect of it is failure is not at all an option. The speed at which things happen, even a small bug in the system can lead to runaway losses. You might have heard of this popular story that was floating around, like how do you lose half a billion dollars in 30 minutes? That was a bug that caused a trivial bug that caused cascaded and caused a lot of failure within that. So you need different approaches. Like you need to carefully review and reason about every line of code you write. You need rigorous backtesting so that all your strategy that you develop is tested against two, three months of data. And you need to do that every time you make a code change. So where you can leverage some of the other cloud environments that are available. And you need very solid risk management modules where in real time you're measuring a lot of these metrics and then acting upon it. Like not just monitoring manually but systems that monitor and take action. So all these things, you also need to automate everything. Like any manual work leads to more errors, causes problems. So a lot of these things that we do, it might look like it's applicable only to a niche system but it's becoming more and more mainstream nowadays. So because each core stops becoming faster, you need to, like if you want to code to run faster, you need to understand modern hardware. You need to write programs that can leverage some of the features that they're doing to help you make things faster. And a lot of these techniques are now being applied to make mainstream systems faster. So you might have heard about Skylar DB which is a port of Kassandra to C++ which on benchmarks is 10 times faster than the Java equivalent. Not just because of the language, which in the language, but because of using techniques that are more friendly to modern hardware. So the days of free lunch are over. So we have to stop being lazy and try to understand this and try to write good programs instead of just relying on throwing money at solving problems. Thank you.