Travis Gosselin
Principal Software Engineer, Developer Experience, GitHub
Toronto, Canada
Actions
Travis is a Principal Software Engineer at GitHub focused on Developer Experience, where he works to improve how developers build, collaborate, and deliver software at scale. He is passionate about simplifying complex systems, shaping effective engineering practices, and creating environments where developers can move faster with greater clarity and confidence. A seasoned speaker, architect, and writer, Travis enjoys sharing insights, exploring emerging technologies, and helping teams turn better developer workflows into meaningful business impact.
Links
Area of Expertise
Topics
Fortifying Your Codebase with GitHub
In a time where security tool sprawl is out of control, centralizing your security processes becomes not just a convenience but a necessity. GitHub's integrated toolset not only bolsters security but also significantly enhances the developer experience. Learn how to leverage the synergies of GitHub Advanced Security and Dependabot to protect your codebase while creating a streamlined, efficient, and enjoyable development workflow.
Feature Flagging at Scale: Considerations For Organizational Success
Feature flags can be transformative for organizations, but they're not a one-size-fits-all solution. As teams grow and projects expand, unique challenges arise. In this session, we'll explore the critical considerations organizations must keep in mind to ensure feature flagging paves the way for sustained success and maturity in feature flag adoption.
API Essentials Toolkit: Tools that Power APIs Developers Love
In the fast-moving world of API development, the right tools can make all the difference—especially in the age of AI. As automation accelerates and complexity grows, it’s never been more important to equip your teams with tools that support clarity, consistency, and velocity. This session explores a curated set of essential tools that every API practitioner should know—spanning the entire API lifecycle. From design and development to governance, documentation, and collaboration, we’ll highlight solutions that boost productivity and support scalable, AI-ready API practices. Whether you're refining your stack or starting from scratch, this toolkit will help you deliver better APIs, faster.
Crafting Consistent APIs at Scale: Embracing Linting & Reusable Models
In an era where digital transformation and AI adoption are accelerating across every industry, the need for consistent, scalable, and robust APIs has never been more critical. AI-powered tools—whether generating code, creating documentation, or integrating services—rely heavily on clean, well-structured API specifications to function effectively. As teams grow and the number of APIs multiplies, maintaining design consistency becomes a foundational requirement not just for human developers, but also for enabling reliable, intelligent automation. This session explores how linting and reusable models can help teams meet that challenge at scale.
We will explore API linting using the open-source Spectral project to enable teams to identify and rectify inconsistencies during design. In tandem, we will navigate the need for reusable models—recognizing that the best specification is the one you don’t have to write or lint at all! These two approaches not only facilitate the smooth integration of services but also foster collaboration across teams by providing a shared, consistent foundation.
Building an Internal Developer Portal that Empowers Developers
Internal Developer Portals are revolutionizing how teams streamline workflows, enhance developer experience, and boost productivity. As AI begins to weave deeper into engineering workflows, having structured, reliable SDLC data becomes essential to unlock its full potential. But for medium-sized organizations with limited resources, the path to success is unclear and fraught with challenges. Simply mimicking or using industry frameworks like Spotify Backstage might seem like a shortcut, but without a clear vision and strategy, it can lead to frustration and failure.
This talk dives into how to build a successful Internal Developer Portal tailored to your unique needs. We'll explore critical steps: making a compelling business case, navigating the buy-versus-build dilemma, designing scalable architectures, driving adoption, and measuring impact in meaningful ways. Packed with actionable insights, you'll gain a roadmap to reduce cognitive load, empower your teams, and align your engineering practices with business goals. Whether you're starting fresh or refining an existing portal, this session will equip you to achieve big wins, even on a lean budget.
AI Enablement in the SDLC: A Strategy Sampler for 2026
AI enablement isn’t buying Copilot and calling it done; it’s a system upgrade for the entire SDLC. Code completion helps, but the real bottlenecks live in reviews, testing, releases, documentation, governance, and knowledge flow. Achieving meaningful impact requires an operating model: guardrails, workflows, metrics, and change management; not a single tool. And because this space is evolving at a relentless pace, AI enablement has to be treated as a continuous evaluation process, not a one-time rollout.
This session shares field notes: stories, failures, and working theories from enabling AI across teams. You’ll get a sampler of adaptable patterns and anti-patterns spanning productivity, systems integration, guardrails, golden repositories, capturing tribal knowledge, API design, platform engineering, and internal developer portals. Come for practical patterns you can pilot next week, and stay to compare strategies with peers working through the same moving target.
A Developer’s Guide to Building Your First MCP Server
As AI agents become a first-class part of software systems, learning to build MCP servers is becoming as fundamental as learning to build RESTful APIs. Many engineers already interact with MCP through IDEs and agent tooling, and building these servers introduces a new set of design considerations beyond traditional request/response APIs. While MCP servers share familiar API concepts, the move to agent-driven, probabilistic clients changes how engineers think about contracts, tool design, output shaping, state management, error handling, and spec adoption. Building MCP servers is emerging as an important capability for all developers and teams.
In this session, we’ll start with what MCP is and how the protocol defines resources, tools, prompts, and elicitations. We’ll walk through the practical decisions involved in building your first MCP server, including transport choices, authentication, tool and resource granularity, server instructions, and context engineering. You’ll see how MCP aligns with and diverges from traditional API design, explore framework options, preview generated MCP servers, and learn how to design for scaling, versioning, gateways, and deterministic error handling in real-world systems.
Engineering the Context That Powers Developers and Agents
Engineering teams have always struggled with fragmented documentation, tribal knowledge, and inconsistent standards. What we now call context engineering is closely related to long-standing knowledge management challenges, but the impact is amplified as AI agents enter everyday development workflows. Gaps, conflicts, and poorly organized context slow developers and lead automated systems to produce unreliable results. Without deliberate strategies, organizations risk scaling confusion instead of capability.
In this session, we will explore practical ways to engineer context and knowledge management that works for both developers and AI agents. Using real examples from building centralized, docs-as-code platforms, we will cover how to organize internal documentation, define ownership between team and platform context, and validate content for gaps and conflicts. We will also examine shared context engineering strategies such as summarization, retrieval, and externalization, including how MCP-based approaches improve clarity, scalability, and execution for humans and machines alike.
Unleashing Deploy Velocity with Feature Flags
A lot of development teams have built out fully automated CI/CD pipelines to deliver code to production fast! Then you quickly discover that the new bottleneck in delivering features is their existence in long-lived feature branches and no true CI is actually happening. This problem compounds as you start spinning up microservices and building features across your multi-repo architecture and coordinating some ultra-fancy release schedule so it all deploys together. Feature flags provide you the mechanism to reclaim control of the release of your features and get back to short-lived branches with true CI. However, what you're not told about feature flags in those simple "if/else" getting started demos is that there is an upfront cost to your development time, additional complexities, and some pitfalls to be careful of as you begin expanding feature flag usage to the organization. If you know how to navigate these complexities you will start to unleash true velocity across your teams.
In this talk, we'll get started with some of the feature flagging basics before quickly moving into some practical feature flagging examples that demonstrate its usage beyond the basic scenarios as we talk about UI, API, operations, migrations, and experimentation. We will explore some of the hard questions around "architecting feature flags" for your organization.
Compelling Code Reuse in the Enterprise
Sharing code and internal libraries across your distributed microservice ecosystem feels like a recipe for disaster! After all, you have always been told and likely witnessed how this type of coupling can add a lot of friction to a world that is built for high velocity. But I'm also willing to bet you have experienced the opposite side effects of dealing with dozens of services that have had the same chunks of code copied and pasted over and over again, and now you need to make a standardized, simple header change to all services across your platform; talk about tedious, frictional, error-prone work that you probably will not do! Using a variety of code-sharing processes and techniques like inner sourcing, module design, automated updates, and service templates, reusing code in your organization can be built as an asset rather than a liability.
In this talk, we will explore the architectural myth in microservices that you should NEVER share any code and explore the dos and don'ts of the types of reuse that you want to achieve through appropriate coupling. We will examine effective reuse patterns, including what a Service Template architecture looks like, while also spending time on the lifecycle of shared code and practically rolling it out to your services. We will finish it off with some considerations and struggles you are likely to run into introducing code reuse patterns into the enterprise.
API Design First: Succeeding with API Governance
Modern HTTP APIs power today’s connected world, acting as the core interface not only for developers, but also for the ever-growing ecosystem of machines, services, and now AI agents. As every organization is increasingly expected to produce and consume APIs at scale, the ability to design, build, deploy, and operate consistent, high-quality APIs has become a key competitive differentiator. With AI accelerating the need for composable, well-structured, and discoverable interfaces, API maturity is no longer optional—it’s essential. However, building and scaling effective API Design First practices across an enterprise is still fraught with manual processes, inconsistent standards, and slow governance models. To succeed, organizations must reimagine API Governance as a strategic enabler—one that prioritizes collaboration, stewardship, and automation.
In this session, we’ll explore the core stages of the API design lifecycle and share how to implement practical, modern governance models that increase productivity without sacrificing control. Drawing on real-world examples, as well as off-the-shelf tooling and custom solutions, we’ll show how to align your teams, accelerate delivery, and produce APIs that are robust, reusable, and ready for both human and AI consumers.
Mastering GitHub: Beyond Source Control
GitHub needs no introduction as the world's premier source code repository. However, over the past several years GitHub has transformed well beyond a great tool for managing source code. It now provides a compelling one-stop-shop of capabilities as part of its platform that enables you to cut loose your disparate jungle of other tooling. Being aware of and learning how to effectively use this Swiss Army Knife of GitHub capabilities can substantially reduce your overall development costs while also reducing your team's cognitive overhead.
Join us for an exciting session where we dive deep into the GitHub toolchain, designed to supercharge developer productivity and unite your teams around a powerful engineering platform. Discover how to optimize pull request lifecycles with protected branch configurations, organizational rulesets, and merge queues. We'll also delve into security vulnerability detection using Dependabot and GitHub Advanced Security Code Scanning workflows that developers will love. Don't miss this opportunity to transform your development process and take your GitHub skills to the next level!
Travis Gosselin
Principal Software Engineer, Developer Experience, GitHub
Toronto, Canada
Links
Actions
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top