Investing in developer experience — how HelloSign migrated to OpenAPI.

For companies that have a public API, having a great developer experience is the key to winning business. Your technical documentation is the main driver in developer’s purchasing decisions, but having excellent tooling plays a close second.
In this session, we’ll deep dive into how and why HelloSign migrated our public API to the OpenAPI spec and how that powers our documentation and SDKs. We’ll dig into specific challenges we faced during the migration and working with various tools for automatic generation. We’ll also share the impact we’ve observed on our customers after we made the switch. You’ll leave with a better understanding of the OpenAPI spec, how it can be used to power exceptional developer experience, and some of the tradeoffs you might encounter if you decide to use it.

I work on the "API Pod" at HelloSign (Dropbox) and own developer experience. In early 2022 we migrated to OpenAPI and use that to power our documentation and all our SDKs. This is one of a few talk ideas that explore the same topic from different lenses.

Using OpenAPI to automatically generate fantastic developer experiences

The OpenAPI spec is the most broadly adopted industry standard for describing modern APIs. Companies of all shapes and sizes are using OpenAPI specs to automatically generate documentation, SDKs, tests, and more. But migrating an existing public API to OpenAPI can be challenging and the ecosystem of tooling can be tough to navigate effectively.
In this talk, we’ll deep dive into HelloSign’s journey migrating to OpenAPI and explore how it’s used to automatically generate a delightful developer experience across documentation and SDKs. We’ll take a broad look at the OpenAPI ecosystem and discuss approaches to selecting the right tooling for your situation. You’ll leave with a better understanding of the OpenAPI spec, the different types of tooling it unlocks, and why it’s worth considering for your own public API.

I work on the "API Pod" at HelloSign (Dropbox) and own developer experience. In early 2022 we migrated to OpenAPI and use that to power our documentation and all our SDKs. This is one of a few talk ideas that explore the same topic from different lenses.

Public APIs are the LEGOs of the web

OAuth and webhooks and rate limits, oh my! Public APIs can add powerful features and functionality to your web app—creating value for your users better or faster than what you can build yourself. But what if you're unfamiliar with public APIs or mostly engineer on a core product? In this talk, we'll dissect a variety of mechanisms common in public APIs. You'll leave with a newfound ability to build with public APIs, ready to use internet LEGOs to build something splendid.

The Software Engineer's Guide to Public APIs

You're comfortable working out of a code base. You've solved technical challenges before! But what happens when you have to reach for an API based tool? For many highly-technical engineers, public APIs are out of sight and out of mind. In this talk, we'll cover a range of mechanisms, from OAuth to Webhooks, that you're likely to encounter when building with a public API. We’ll go through live examples and dive into a new-to-me public API chosen by the audience. You'll leave with a newfound understanding and appreciation of public APIs, ready to go forth and connect all of the things!

Strive to be a comb-shaped developer

Solving technical problems requires technical skill, but it's our lived experiences that make us who we are. Many a technical challenge has been solved by simply approaching it from a different perspective. In this talk, we'll discuss the concept of a "comb-shaped developer" and how having a broad range of experiences makes you a better engineer. Come prepared to have a serious discussion about how our differences can lead to better software for everyone.

Static Site Generation: Then and Now

Join me for an exciting adventure through static site generation and large-scale developer documentation. See how far this technology has come by comparing live examples of technical documentation created through static site generation technology from the years 2012 and 2021, both sites generated from the exact same public API spec. We'll pick apart the new sample and discuss challenges, trade-offs, and more! On this quest, our companions shall be JavaScript and Python with quirky sidekicks Stone, Pyxl, and GatsbyJS.

Dropbox has large, outdated developer documentation that is automatically generated (https://www.dropbox.com/developers/documentation/http/documentation). I rebuilt it using GatsbyJS. The system consumes the same API spec, but generates a significantly better site , with substantial improvements to performance, accessibility, and SEO. Live version available here: https://taylorkrusen.github.io/cupcake-docs/

APIs and Automatic Generation are Awesome, Actually

A year ago, I’d have told you that APIs and automatic generation are oil and water. I’d spent too long stuck in a world where scalable API authoring came at the cost of a permanently sub-par developer experience. These days, I feel the exact opposite — APIs that use automatic generation the right way consistently win more developers.
In this talk I’ll share the journey that changed my mind — helping migrate the HelloSign public API to OpenAPI in early 2022. I’ll cover the challenges we ran into, discuss the tools we chose for generating documentation and SDKs, and we’ll explore the completed solution together. I’ll also talk about the initial goals of the project and impact we’ve observed since launch. You’ll leave with a deeper understanding of the OpenAPI spec and (hopefully) shared enthusiasm for using automatic generation to create truly delightful developer experiences for users of your public API.

I work on the "API Pod" at HelloSign (Dropbox) and own developer experience. In early 2022 we migrated to OpenAPI and use that to power our documentation and all our SDKs. This is one of a few talk ideas that explore the same topic from different lenses.

If You Build It Will They Come?

You built it, but will they come? In today's world simply building a great app isn't enough. The digital marketplace is fragmented across many tools and drawing attention to your app requires careful planning. In this talk I will teach you to build a deliberate, well thought out launch plan and why that is essential to gain awareness and users.

What's All The Fuss About Serverless?

Dude, where's my server?! The word 'Serverless' can be a bit misleading, but this architecture style has exploded in the tech industry and offers a myriad of unique benefits. Unfortunately, real comprehension of this concept has been abstracted away just as much as our server—turning the word 'Serverless' into little more than marketing jargon. In this talk we'll define Serverless, work through a sample, discuss the benefits / compromises, go over real-world use cases, and examine the Serverless economy.

Writing End-To-End Tests Using Headless Chrome and Puppeteer

End-to-end tests are great! They ensure a great experience for your users, prevent bugs, and save money. However, they also have a history of being brittle and slow... but not any more! In this talk we'll cover end-to-end testing conceptually, then use headless Chrome and Puppeteer to write powerful tests that can run on top of any stack.

Samurai, Shinto, and Sake: What Japanese Culture Can Teach Us About Being Great Developers

Japan has a rich, beautiful culture steeped in tradition and values. The concept of Kaizen (continuous improvement) is widely talked about in the context of business. However, a developer has more to gain from the Bushido code than from Kaizen. In this talk we will discuss how certain Japanese concepts can make you a better developer—changing you from a keyboard warrior to a keyboard samurai.

Serverless Webhooks: Friend or Foe?

Pairing an automatic event notification with an event-based cloud architecture seems obvious; an application emits an event and 'code in the cloud' responds to it. Why, then, is setting up Webhooks on Serverless harder than getting gum out of your hair? Join me and untangle the mystery. In this talk we'll cover webhook fundamentals, compare webhooks from several different vendors, and then implement them in node.js on multiple serverless ecosystems.

Building an OAuth Flow in a Node.js CLI

Ready for others to benefit from your integrations and code? You'll probably need OAuth 2.0, but building your first OAuth flow is about as fun as stepping on Legos. In this talk we'll break down how to build an OAuth flow, then dissect an OAuth implementation done in a node.js CLI; a challenging use case that will make OAuth 2.0 feel more approachable than ever before.

Write better docs by NOT being an expert

Technical knowledge is hard to consume and harder to teach. You need to educate developers about your public API or product, but how do you keep from losing them in the complexity? In this talk, we’ll cover strategies to create educational resources that make complex technical topics feel more approachable. I'll share my own insights into technical enablement and why being genuine is more valuable than being an expert.

Stop Documenting and Start Teaching

Using your docs to simply document your product is a waste of valuable attention. Developers come to your documentation with a need. They might not even know the words to describe that need, let alone understand how to navigate your docs to find a solution for it. In this talk, we'll explore how reframing your approach to center teaching leads to much better documentation that helps your developers succeed. We'll cover information architecture, levels of abstraction, and other tools for building truly exceptional documentation. If you're ready to turn your docs into a competitive advantage, then this session is for you.

Companies will pay you to do that?!

Don't let whiteboards or glass ceilings tell you no. YOU are so much more than your coding expertise. It's your unique story, experience, and insights that bring the real value. For anyone learning to code, thinking about learning, or learned-but-couldn't-pass-technical-interviews (... that's me), I'm here to tell you there's more to tech than engineering... a lot more.
An appetite for technical knowledge and the right mindset can open up a whole wide world of roles in tech. In this talk, we'll dive into some of the different jobs and career paths that involve code, but don't require shipping against a core product. We'll talk about Developer Relations, API Support, Business Development, Customer Success, and more! Come learn how coding can shape your career journey even if engineering isn't the right role for you.

First public delivery. A topic near and dear to my heart as a bootcamp graduate that failed every whiteboarding session I did.

Securing Microservices: Mastering Authentication for Secure, Robust Applications

Authentication plays a critical role in microservices—it’s tough to get right and costly to get wrong. But those challenges can also be an asset.
In this session we’ll:
- Explore the nuances of Monolith vs Microservice Authentication.
- Highlight the need for an iterative authentication strategy to ensure secure interactions between services, resources, and users.
- Discuss a range of authentication mechanisms, their tradeoffs, and the role of an API Gateway.
- Cover the practical implementation of popular authentication techniques like SSO, JWT, and OAuth in a microservices application.
You’ll leave this session with a more comprehensive understanding of authentication in microservices and the tools you need to build your own authentication strategy.

Explaining Passwordless to your Grandparents

“Grandma, Grandpa, we need to talk about passwords…”
Explain like I’m 5? Nah. In this session, we’ll explain like you’re 95! Let’s convince our relatives to toss their leather-bound password journal.
Authentication is a critical part of modern apps, but the traditional auth methods we’ve used for years are starting to show their age. In this session, we’ll dive into passwordless like we’re teaching it to our grandparents. We’ll explore the exciting new world of modern authentication that goes beyond usernames and passwords, which are starting to feel a bit dated. From Biometrics to Tokens to Passkeys, we’ll cover the latest trends and best practices that are revolutionizing the way we keep applications secure. Join this session and learn to modernize your authentication methods, improve your user experience, and keep your data safe. This isn’t the authentication that your grandparents know …yet, but it keeps them safer and is harder to lose!

MDX vs. Markdoc: Delighting Users with Interactive Documentation.

In the modern API economy, documentation is the most important “frontend” that SaaS tools can have. Creating a great experience there directly impacts your bottom line growth. And—thanks to modern frontend tooling (and the OpenAPI spec)—building engaging, interactive documentation is an incredibly rewarding experience.
In this session, we’ll dive into MDX and Markdoc, two leading technologies for building interactive docs that create an “app-like” experience for your users. We’ll discuss their benefits and tradeoffs, then look at real-world implementations. I’ll share firsthand insights from large documentation rebuilds done with both tools, what it was like using them in production, and compare the authoring and development experience for both. This session will also touch on the role of OpenAPI and the Docs-like-Code architecture powering this new era of documentation technology.

First time giving the talk but I've led two massive documentation rebuilds over the past couple of years. One was with MDX and the other with Markdoc. So I've got some really neat knowledge to share!

Delighting Developers: Why You Need an OpenAPI Spec

​​In our current landscape, great developer experience wins business. In order to see success and adoption, you need to ensure that developers are successful with your API at every step of their journey. One of the most powerful ways to achieve that is by implementing the OpenAPI Specification, the most broadly adopted industry standard for describing APIs, and tooling related to it.
In this talk, we’ll explore how embracing OpenAPI can delight your developers and power the growth of your API. Here’s some of what we’ll cover:
- OpenAPI fundamentals (landscape, benefits)
- Creating high quality OpenAPI Specs
- Streamlining API documentation and tooling
- Fostering collaboration and iteration
Join this session to learn about the transformative impact that adopting OpenAPI can have on your developer experience. You’ll learn how OpenAPI can empower your developers to learn about and successfully build with your API.

Minimum Viable Authentication: The Art of Balancing UX and Security

Successful apps grow in complexity fast. But striking the right balance between usability and security directly impacts your growth, especially when it comes to authentication. Poor security means increased risk, but adding authentication factors increases user friction and can cause user drop off. In this session, I’ll introduce the concept of “minimum viable authentication” — finding the optimal level of authentication at different touchpoints in your application.
We’ll discuss a broad range of authentication factors—from biometrics to passwordless to tokens—and the implications of each. You’ll learn to optimize authentication UX by evaluating your app’s risk tolerance, the context you have about your users, the actions they’re trying to perform, and the level of friction introduced by combining different authentication factors. Come learn how Minimum Viable Authentication can help you deliver secure, delightful authentication experiences to your users.

Great UX, Right Away — Embracing Authentication as a Product Experience

Your app’s authentication should deliver great UX or your first touch might be your last impression. Like it or not, users view authentication as an extension of your brand and a fundamental part of their experience using your product. Is your sign in experience gatekeeping the growth of your app?

This session will highlight the importance of treating authentication not just as a security measure, but as a critical component of the product experience. We’ll cover real world examples and share strategies for creating authentication flows that are reflective of your product’s value. We’ll also discuss how well-designed authentication flows leads to increased customer satisfaction, deeper engagement, and bottom line growth. This is a great session for anyone looking for ways to amplify the success of a growing app.