The W3C/IETF plan to support real time communication in the browser, WebRTC, is moving from high-flown concept to somewhat messy, but useful, reality. Generally, I am a fan. WebRTC offers new opportunities to both indie developers and the established players. It will undoubtedly accelerate the adoption of new conversational services at the expense of traditional fixed and mobile telephony. There are a lot of interesting and important topics to explore related to WebRTC but I want to start by talking about what kind of ecosystem will be involved in successful WebRTC services. A lot of the technically focussed analysis of WebRTC has not highlighted the extent to which WebRTC services will require multiple components and company inputs to be integrated.
To start this discussion we need to understand a bit about how WebRTC is structured. This isn’t a WebRTC tutorial but a sketch showing roughly where the main functions reside. The heart of WebRTC is a new W3C standardized API between the browser and Javascript running in a web page. The API provides three elements:
- Mediastream which allows the Javascript to access media inputs on the local computer (eg cameras and microphones);
- RTCPeerConnection which allows connections that send and receive media to be made with peer devices running WebRTC; and
- RTCDataChannel which allows generic non-media data to be sent over an RTCPeerConnection channel.
In this discussion I am just going to focus on RTCPeerConnection. RTCDataChannel is a really interesting initiative with a lot of implications but it’s probably the least mature part of WebRTC and not really central to the point I want to make about ecosystems. Mediastream is the most mature element but it doesn’t feature majorly in my thoughts on the value chain.

WebRTC – Simplified service architecture
The most interesting point about these APIs for my discussion is where W3C decided to draw the boundary of the RTCPeerConnection API. It is quite different for the media part of the connection and the signalling part. In the case of the media the API has been put at a high level leaving the Javascript with a rather abstract view of the media. The browser takes on the task of managing the media coding and doing the heavy lifting to make media work nicely across unreliable networks. The browser is responsible for packet loss concealment, echo cancellation, media adaptation to varying network bandwidth, and dynamic jitter buffering and any proprietary technologies used to subjectively improve the perception of media. In practice this means that a lot of the features that dictate the quality of the service as perceived by users will be controlled by the browser. It also means that browser developers will need access to media technology that has traditionally been the domain of telephony app developers.
For signalling the WebRTC API is at a somewhat lower level than it is for media. The RTCPeerConnection component in the browser manages establishment of media connections between WebRTC peers. The browser also contains the tools to perform NAT and Firewall traversal for the media based on the ICE framework (ie using STUN and TURN). The Javascript interacts with, and manages, these capabilities using the API. However WebRTC does not define any service signalling between WebRTC peers or between WebRTC clients and network servers. It is up to the Javascript to implement its own signalling protocols based on the requirements of the designer of the unique WebRTC service. If you want to have a WebRTC client that talks SIP then you can do that, but you need to implement the SIP signalling and the interworking to the WebRTC APIs in Javascript. Whereas the browser largely controls the user experience for the media the Javascript will control the functional user experience.
Getting the Javascript right for any non-trivial service in the very asynchronous environment of real time communications management is going to be tricky. Despite the work of W3C there are going to be browser dependencies no doubt and subtleties about how to use the ICE capabilities in the browser to best effect that will take time to learn. Many WebRTC developers will choose to use a public or proprietary library built on top of RTCPeerConnection which provides a higher level interface as part of their app. Library providers will be another part of the ecosystem and will corral a lot of the value. What’s not clear is whether proprietary libraries will be able to retain value in the face of open alternatives.
Though WebRTC is a browser technology the complete services will need network servers as part of the solution. At least day one WebRTC services will rely on network servers for media transcoding, signalling interworking, media conferencing and media forking for multicast. In the open environment where Javascript controls the signalling it will be up to service designers to choose the functional split between clients and servers. Organisations with existing skills in VoIP systems are going to hold value in the server components and the systems design.
Lastly, we should not forget about the (not really) “dumb” pipes that all this flows over. WebRTC changes browser behaviour quite profoundly by creating the potential for a lot of traffic on new protocols and new IP ports. To some extent the support of web sockets have already opened up the use of multiple protocols on the browser but WebRTC will make this much more common. All this will have impacts on local personal firewalls, home gateways and ISPs but that is a discussion for another day.
In summary the factors that lead to the final user experience for a WebRTC service are going to be distributed across several technology components that are likely to be obtained from different sources. Some developers (eg in browsers and for the Javascript) are going to face problems that are outside their traditional areas of expertise and building the right skill set by recruitment or acquisition is going to be important to successful development of services. Vendors will take different roles as suppliers of individual components and/or complete solutions. Successful WebRTC services will not just require a good service concept but also the technical ability to design the service in a way that makes the best use of the tools available and integrates the value added by multiple underlying components.