Every industry has friction points, but few have historically been as fragmented for developers as telecommunications. If you’ve ever tried to build something that interacts with mobile networks, you’ve quickly found yourself navigating a maze of disconnected APIs, formats and docs styles.
Of course, nobody is to blame, and with telcos competing in business, it’s not surprising that, until recently, there’s been very little common ground between the tech they use.
Unfortunately, developers - and in turn, customers - paid the price for this, with building tools and solving problems made more complicated than it needed to be.
Recently, though, something unusual has been happening. Major telcos around the world have begun collaborating on an open-source initiative called CAMARA, hosted by the Linux Foundation. Rather than treating APIs as competitive territory, they’re now contributing to a shared,
standardised set of network capabilities anyone can use.
The interesting story here isn’t “look at this new API.” It’s that competitors are agreeing on a common foundation because the alternative has been holding developers back for years.
Why Fragmentation Hurts Devs
Competition is great when it pushes companies to improve their products. But when the competition happens at the infrastructure layer, where each provider exposes similar capabilities in their own way, innovation slows down.
For developers, this approach meant learning multiple integration patterns for the same basic task, inconsistent or incomplete documentation, region-specific behaviours and edge cases, and increased maintenance burdens as an app scales.
Developers don’t skip network features because they’re uninteresting, they skip them because the cost of implementing them is too high, whether it’s in terms of time, money - or both.
A Shared Standard Level
CAMARA’s approach is simple: if competitors build the same capability differently, and developers have to support all those differences, everyone loses.
So instead, telcos contribute to a shared set of OpenAPI-defined network APIs, ensuring the same structure, behaviour, cloud endpoints and open-source specifications and docs.
An Example: Verifying a Phone Number
One of the most common onboarding steps in mobile apps is verifying a user’s phone number. Traditionally, that meant sending an SMS code, waiting, and hoping the user doesn’t mistype it or get distracted.
A standardised API makes it much simpler: instead of sending a code, you ask the network a yes/no question, is this device actually associated with this phone number?, and get an immediate response.
Here’s a minimal TypeScript example based on CAMARA’s specification:
async function verifyPhone(phoneNumber: string): Promise<boolean> {
const res = await fetch("https://api.example.com/number-verification/v1/check", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.ACCESS_TOKEN}`,
"Content-Type": "application/json"
},
body: JSON.stringify({ phoneNumber })
});
const data = await res.json();
return data.verified; // true | false
}
No SMS. No switching apps. No codes to type. Just a simple experience for users, and a smoother process for users. Everybody wins.
And because the API is standardised, this works across operators and markets,without a new integration each time.
Why This Model Matters
The real lesson here isn’t about telecommunications at all, it’s about what happens when a corner of the tech industry decides that shared infrastructure is a rising tide that lifts all boats.
We certainly enjoy seeing the work CAMARA is doing, particularly in an increasingly competitive tech industry, with competitors realising that collaboration at the right layer leads to a healthier ecosystems for everyone: developers, businesses, and ultimately the users of the apps built on top of it.