The most important thing I learned at work, nobody taught me at University
When I finished my degree, I could build you an app. I could stand up a database, write the backend, wire up a frontend, and deploy the whole thing. What I could not do, and did not really know was a job, was making two systems that already existed talk to each other. That connecting up work turns out to be something organisations across almost every industry depend on to keep running day to day.
What University prepared me for
University teaches you to build things from scratch. You start with an empty file and you fill it. Every assignment is its own little world where you control all the pieces, the data is clean, and the other systems you talk to are ones you also wrote. It is a good way to learn how software works. It is not a great picture of what most software looks like.
In the real world, almost nothing is built from scratch. Companies already have systems. A finance system here, an HR system there, a CRM, a warehouse system, a payroll platform, half of them older than I am. Many of them were built in isolation, designed to do their own job well rather than to talk to anything else, and yet the business needs them to. Someone updates a record in one system, and it has to show up in three others.
That connective work, getting existing systems to share data reliably, is called integration, and it is quietly holding up almost everything you use. Every time an order reaches a warehouse, a payment system shows up on your statement, or a form you filled in turns into an email, some integration moved that data from one system to another. You never see it, but take it away and the whole thing grinds to a halt.
To be fair, it is not that integration is a total secret at uni. You might touch APIs in a web subject, or get a taste of deployment in a cloud or DevOps unit. But it gets a passing mention at best, and the real thing is nothing like mentioned. Nobody sits you down and teaches you what happens when two systems have to agree and they refuse to.
Why you never notice it
Here is the strange thing about integration: when it works, it is completely invisible.
You log into a website with your Google account. You buy something and the confirmation email arrives before you have closed the tab. Your bank balance updates the moment a payment clears. Every one of these scenarios involves two or more separate systems handing data to each other in the background. You never think about it because you’re not supposed to. Good integration is felt only in its absence.
You notice it, the day it breaks. The order that never showed up. The account that says you paid when you did not, or did not when you did. The app that spins forever because something it depends on quietly stopped answering. That is integration failing, and suddenly it is the most visible thing in the world.
“Just call the API” is a lie
Early on, I thought integration would be simple. System A has an API, System B has an API, you call one from the other, done. That sentence is technically true and almost completely useless.
The hard part is never the call. It is everything around it.
The two systems describe the same thing differently. One calls it a customer, the other calls it an account. One expects a date as 2026-08-06, the other wants 06/08/2026, and it will not tell you which, it will just fail. One system is available and the other is down for maintenance, so you have to decide what happens to the data that was mid-flight. A message gets sent twice and you have to make sure the second one does not create a duplicate. A run fails halfway and you have to work out whether anything was lost, or whether it is safe to just run it again.
None of that is in the “call the API” version. All of it is the actual job. Most of what I do is not writing the happy path, it is handling every way the happy path can go wrong, because in a system with real users and real money, it will.
Learning something with no textbook
The obvious worry, coming in, is how you learn any of this when it is not the kind of thing you can just look up. A lot of it is specific to a platform, a client, or a system that only a handful of people have ever touched, so there is no clean tutorial for the exact problem in front of you. For me, two things sorted that out, and neither was being left to figure it out alone.
The first was starting in support. Before I was building anything, I was helping keep existing client integrations running, and that turned out to be the best possible way in. Support means you see across everything. In my first months I was exposed to all three of the main platforms we work with, Azure, Boomi and MuleSoft, rather than being funnelled straight into one.
When something misbehaves and you have to figure out why, you end up learning how the pieces actually fit, what a healthy integration looks like, and how the same problem shows up differently on different platforms. You get the overview before the detail, which is exactly backwards from how University does it, and much more useful.
Where the structure helped
The second thing was that none of this was a case of sink or swim. Adaptiv’s Graduate Programme came with an actual structure to follow, a training path that steps you through the fundamentals of each platform, the tools, the certifications and the concepts, alongside the real support work. So I was learning in two directions at once: the structured material gave me the theory and the vocabulary, and the live tickets showed me what it all looks like when it is running in the real world and occasionally falling over. Having both at the same time is what made it click.
The other quiet advantage was the people. I had experienced people around me to talk things through with, and a team that treated my questions as normal rather than annoying. One rule I picked up early: reading something twice is safe, but changing something you do not understand is how you turn one problem into two. When you are not sure, you ask, and the senior people would far rather answer a question than untangle a mess made trying to avoid asking one.
If you are a student reading this and none of the integration stuff sounds familiar, that is not a gap in you, it is a gap in what degrees cover. It is very learnable on the job, as long as you land somewhere that actually teaches you rather than throwing you in. If that is the kind of start you are after, it is worth keeping an eye out for Adaptiv’s Graduate Programme, because the mix of support exposure, a structured training path and people who want you to ask is genuinely the thing that made the invisible part of software make sense to me.
None of this was in my degree. All of it turned out to be the job. And now, every time something just works, a login, a payment, an email that arrives on time, I know how much invisible plumbing is holding it up, and I have a quiet appreciation for the people keeping it running.