Presentation: Front-End APIs: Powering Fast-Paced Iterations
What You’ll Learn
- Learn how LinkedIn uses API modeling and how it evolved over time.
- Discuss how LinkedIn embeds an entity model into a view model to keep all views in sync.
- Gain knowledge on how they add new features to the API on the server side without any changes on the client.
Abstract
LinkedIn uses a unified API server to power our new flagship experience on all platforms (desktop web, mobile web, iOS and Android). The API and clients are released using a completely automated continuous release and deployment pipeline, to enable a rapidly evolving product.
We explore our original ideas behind API modeling, the challenges we’ve faced, and how we are evolving our modeling strategy over time based on our learnings. We will present a use-case study of building the templated API behind LinkedIn’s new in-app notification experience. This new API allows new notification types to be rapidly introduced without requiring any client-side changes while continuing to preserve baseline requirements around backward compatibility, data consistency and caching.
Interview
Karthik: I work for the Application Infrastructure team at LinkedIn. Specifically, I lead the mobile infrastructure team.
Our team designs and builds shared libraries (examples include networking, caching, image loading, analytics, performance instrumentation etc.) and tools (build, debug and test tools) used by all native mobile applications (iOS/Android) at LinkedIn. Since our mobile clients are thin, we also focus a lot on the server-client interaction. This includes but is not limited to, the structure of the API exposed by the server, the wire format, compression algorithms to use when communicating between client and server etc.
Aditya: I lead the infrastructure development for the frontend API server, which powers the LinkedIn app on iOS, Android and Web. Our team is focussed on laying down the foundation of our frontend API server, its overall architecture, modeling direction, testing strategy. Our team is also responsible for developer happiness and operational stability of the service. This drives us to push the boundaries on coming up with innovative ways to enable application teams to ship features as fast as possible with stable infrastructure
Karthik: LinkedIn has massive scale (in terms of user base), as well as significant complexity in the structure of APIs we expose to our clients on account of diverse features. In addition, we also move fast and release new code to our API server/web clients multiple times a day, and mobile apps once a week. A huge army of developers, designers, site reliability engineers, product managers, engineering managers, project managers work smoothly in tandem to make this happen. Since the product moves so fast, designing an API that evolves elegantly and minimizes engineering work for adding new features, while being relatively stable is crucial.
This talk charts our journey along various approaches for API design that we’ve explored, our missteps and learnings at each stage, where we are now and a sneak peek into our future direction.
Aditya: The talk is going to be around the evolution of how we started with entity-based modeling. This is where you describe an entity that's sent to the client and then the client does the transformation. We are moving from this approach to a place where we have our own language that the client can use to stitch everything together as it needs. The talk will have what we've learned from this approach, and how it helps us shoot for shipping features to consumers without making client-side changes. The goal is to monitor and power these experience directly from the server side.
Karthik: How to design and structure APIs that can evolve quickly to support various client UI use cases, while making minimal/no changes to client side code to support these new use cases.
Similar Talks

Tracks
Monday, 26 June
-
Microservices: Patterns & Practices
Practical experiences and lessons with Microservices.
-
Java - Propelling the Ecosystem Forward
Lessons from Java 8, prepping for Java 9, and looking ahead at Java 10. Innovators in Java.
-
High Velocity Dev Teams
Working Smarter as a team. Improving value delivery of engineers. Lean and Agile principles.
-
Modern Browser-Based Apps
Reactive, cross platform, progressive - webapp tech today.
-
Innovations in Fintech
Technology, tools and techniques supporting modern financial services.
Tuesday, 27 June
-
Architectures You've Always Wondered About
Case studies from the most relevant names in software.
-
Developer Experience: Level up Your Engineering Effectiveness
Trends, tools and projects that we're using to maximally empower your developers.
-
Chaos & Resilience
Failures, edge cases and how we're embracing them.
-
Stream Processing at Large
Rapidly moving data at scale.
-
Building Security Infrastructure
How our industry is being attacked and what you can do about it.
Wednesday, 28 June
-
Next Gen APIs: Designs, Protocols, and Evolution
Practical deep-dives into public and internal API design, tooling and techniques for evolving them, and binary and graph-based protocols.
-
Immutable Infrastructures: Orchestration, Serverless, and More
What's next in infrastructure. How cloud function like lambda are making their way into production.
-
Machine Learning 2.0
Machine Learning 2.0, Deep Learning & Deep Learning Datasets.
-
Modern CS in the Real World
Applied, practical, & real-world dive into industry adoption of modern CS.
-
Optimizing Yourself
Maximizing your impact as an engineer, as a leader, and as a person.
-
Ask Me Anything (AMA)