SonarQube is a server plus a family of scanners, and most confusion about it comes from not knowing which side does what. The scanner runs where the build runs. It discovers source files, applies language analysers, and uploads a report; the server's compute engine then processes that report, tracks issues against previous analyses and updates the project. Nothing is analysed on the server, which is why analysis time is a build concern and why the scanner needs to see what the compiler sees.
That last point is what separates languages. For interpreted and JVM languages the scanner can read sources directly, though the Maven, Gradle and dotnet integrations exist because they can hand over the compile classpath and produce far better results. For C, C++ and Objective-C the analyser needs the actual compilation commands, captured by the build wrapper or supplied as a compilation database — which is why an unconfigured C++ project reports almost nothing and looks like a broken installation.
On the server, two constructs carry the meaning. A quality profile is the set of rules applied per language, inheritable so a legacy service can be held to a different standard than a new one. A quality gate is the pass or fail condition evaluated after each analysis, and modern practice evaluates it against new code — code added or changed since a defined baseline — rather than against the whole repository. Issue tracking between analyses uses line hashes rather than line numbers so a reformat does not resurrect everything, and issues carry a lifecycle of their own: open, confirmed, resolved, false positive or accepted, with security hotspots reviewed rather than fixed. Around all of it sit branch and pull request analysis with decoration in the source control platform, permission templates and identity integration, and a database and search index whose growth is the main operational concern on a large instance.
Why this skill matters now
Static analysis moved from a report someone read quarterly to a control that blocks a merge, and that changes what skill is required. Producing findings is easy; producing findings that a development team accepts, that block genuinely bad changes and that do not fail a build for a decade-old codebase is a design problem involving profiles, gates, new-code definitions and an exception process.
Security accelerated the shift. Vulnerability and hotspot rules, OWASP and CWE mapping, and taint analysis pulled static analysis into the security programme, so findings are now read by people who do not write code and who expect evidence that each one was triaged. That makes issue lifecycle discipline, review of security hotspots and reporting as important as the rules themselves.
The third pressure is scale and language spread. Organisations run hundreds of repositories across half a dozen languages, and someone has to keep analysis fast, keep the server and its index healthy, wire pull request decoration into the source control platform, and manage rules centrally rather than per project. Add compiled-language analysis, which needs build integration to work at all, and the result is a role that sits between engineering, security and the delivery pipeline — which is precisely the profile organisations struggle to hire.