API Design Principles for Accelerated Development


Published on

One of the largest issues in API architecture development is that the task is often driven by the pragmatic indoctrination of a specification into a product rather than designing around the speed and ease of development, usually due to a separation between the engineering teams and their core developer user base.

Extending upon the ideas of API design around developer accelerated development delivered in the PayPal keynote, we will take a deeper look into some of the great techniques delivered to us through the RESTful specification, applying them to developer API consumption practices with the intention of creating efficient best practices for rapid development.

Within this talk we will explore what we have learned through reconstructing our API backbone at PayPal for our developer community, including:
- API automation practices for code reduction and application longevity
- Open security standards that promote developer integration ease and maintain strict security practices
- RESTful API architecture best practices for developer centric accelerated development

Published in: Technology, Design
  • Be the first to comment

No Downloads
Total views
On SlideShare
From Embeds
Number of Embeds
Embeds 0
No embeds

No notes for slide
  • At the end of the day, we need to be designing for the developers
  • API system standards vs. efficient developmentREST is all about the tradeoffs
  • Lowering perceived latency for developers
  • Reduction in system layeringCaching can reduce reliability (stale data)
  • Protects new systems from legacy APIs
  • Layering the system to separate legacy systems
  • Use HTTP properly – standard request and response types
  • Building in automation, using HATEOAS
  • Heavier payloads being sent throughReduction in developer code size & scalable architecture
  • Use HTTP properly – standard request and response types
  • Offload complexity to the implementing provider
  • API Design Principles for Accelerated Development

    1. 1. For Accelerated DevelopmentAPI Design PrinciplesJonathan LeBlancHead of Developer Evangelism (North America)Github: http://github.com/jcleblancSlides: http://slideshare.net/jcleblancTwitter: @jcleblanc
    2. 2. The Exploration of API DesignBlank Slate Constraints
    3. 3. Building APIs for Developers
    4. 4. The Tradeoff Decision
    5. 5. Developer efficiency task 1Lowering perceived latency for developersLower Perceived Latency
    6. 6. What’s the Tradeoff?System LayeringResult Caching
    7. 7. Layering the SystemEncapsulates legacy systemsSimplified componentsBetter load balancing abilitiesSystems can evolve independantly
    8. 8. Separation of Concerns
    9. 9. Stateless System Latency IssuesData DuplicationA + BA + C
    10. 10. Caching for Latency Reduction
    11. 11. Developer efficiency task 2Use HTTP properly – standard request andresponse typesUse HTTP Properly
    12. 12. What’s the Tradeoff?
    13. 13. Requests and ResponsesGET / PUT / POST / DELETEhave specific actionsProper status codes and errorresponses
    14. 14. Don’t do This{"error": "error 10008"}Do ThisHTTP/1.1 400 Bad RequestContent-Length: 35{"message":"Problems parsing JSON"}Descriptive Messaging
    15. 15. Developer efficiency task 3Building in automation – using HATEOASBuild in Automation
    16. 16. What’s the Tradeoff?Payload Size Code Length
    17. 17. How we Normally Consume APIs
    18. 18. Using HATEOAS to Automate
    19. 19. "links": [{"href":"https://api.sandbox.paypal.com/v1/payments/authorization/6H149011U8307001M","rel":"self","method":"GET"},{"href":"https://api.sandbox.paypal.com/v1/payments/authorization/6H149011U8307001M/capture","rel":"capture","method":"POST"},{"href":"https://api.sandbox.paypal.com/v1/payments/authorization/6H149011U8307001M/void","rel":"void","method":"POST"}]
    20. 20. Developer efficiency task 2Secure Data Resources
    21. 21. What’s the Tradeoff?Security Usability
    22. 22. Some Security ModelsProprietary SolutionBasic AuthenticationOAuth 1.0aOAuth 2 / OpenID Connect
    23. 23. Developer efficiency task 4Offload complexity to the implementingproviderOffload Complexity
    24. 24. The ComplexitiesAuthentication / AuthorizationLegacy API supportWorking between versioningAPI changes that break implementationsReduction in latency
    25. 25. API architecture is all about tradeoffsYou are not making a perfectsystem, you are making a perfectsystem for your developersBringing it all Together
    26. 26. http://bit.ly/api_design_for_devsThank You!Jonathan LeBlancHead of Developer Evangelism (North America)Github: http://github.com/jcleblancSlides: http://slideshare.net/jcleblancTwitter: @jcleblanc