Adam Wathan presents a detailed walkthrough of test-driven development (TDD) in Laravel, demonstrating how to build features from scratch using both acceptance tests and unit tests. He builds a Twitter clone called 'Tweeter' and shows how to implement features like viewing user profiles and sending follower notification emails, while explaining best practices around using mocks, spies, and fakes in testing.

Adam Wathan presents a talk on improving code quality by eliminating loops, conditionals, and temporary variables using Laravel Collections and functional programming concepts. He demonstrates how to refactor complex nested loops into cleaner collection pipelines using methods like map, filter, flatMap, and contains. The talk includes practical examples ranging from data transformation to simple conditional checks, showing how collections can make code more expressive and maintainable.

Matthew Machuca gives a detailed talk about testing methodologies, focusing on behavior-driven development and test storytelling. He shares his experience working at Think Through Math, where he discovered and fixed bugs in their student-teacher pairing algorithm through better test practices. The talk emphasizes the importance of writing clear, expressive tests that tell a story and avoid coincidental passing tests.

Sandi Metz delivers a talk on code smells and refactoring, focusing on practical techniques to improve code quality. She explains how to identify code smells, apply appropriate refactorings, and use dependency injection to make code more testable. The talk emphasizes the importance of making incremental improvements and understanding classic Object-Oriented programming principles.

Chuck Reeves delivers a comprehensive talk on software estimation techniques, emphasizing the importance of accurate estimates while acknowledging their inherent uncertainty. He discusses various methods for breaking down requirements, managing scope creep, and dealing with the political aspects of estimation. The talk covers practical approaches like fuzzy logic, the Wideband Delphi method, and using historical data to improve estimation accuracy.

A talk about YAGNI (You Aren't Gonna Need It) principle in Laravel development. The speaker discusses how to avoid over-engineering by only implementing features when they're actually needed, while maintaining balance between simplicity and necessary complexity. He covers the stages of adopting YAGNI, from initial resistance through to confidence, and provides practical examples of when to apply or not apply YAGNI in Laravel applications.

A comprehensive talk about writing better Laravel code by focusing on proper use of Eloquent ORM features. The speaker discusses model defaults, relationship management, custom collections, and report generation patterns. He emphasizes the importance of making code readable and semantic, using real-world furniture-making analogies to illustrate concepts of craftsmanship in software development.

Matt Stauffer discusses how to properly customize Laravel applications while maintaining code discoverability and following best practices. He emphasizes starting with Laravel's intended customization points in the app directory before moving to more advanced container-based modifications. The talk covers both philosophical approaches to customization and practical implementation details, with a focus on making customizations that future developers can easily understand.

This talk focuses on dependency management in PHP projects using Composer. The speaker discusses how Composer has evolved from a simple PHP package installer to a critical piece of infrastructure. He covers best practices for managing dependencies, handling updates safely, dealing with compatibility issues, and mitigating risks associated with third-party dependencies. The talk emphasizes the importance of proper version control, change management, and business considerations when dealing with dependencies.

Jeffrey Way shares 9 code refactoring techniques to improve Laravel applications, focusing on simplicity and practical solutions. He emphasizes letting code 'grossness' guide refactoring decisions rather than premature optimization, and advocates for optimizing code for deletion rather than trying to future-proof everything. The talk provides concrete examples of patterns like decorators, query objects, and event handling while warning against over-engineering.

In this talk, Adam Lavin discusses a common misunderstanding about object-oriented programming, specifically how methods should be thought of as affordances (properties that tell you what you can do with an object) rather than abilities. He demonstrates how this shift in thinking leads to cleaner, more maintainable code through real-world examples from his course platform, including how to eliminate agent nouns, break up God objects, and when to use simple functions instead of classes.

A detailed talk about practical design patterns and code organization in Laravel applications, focusing on when and how to implement different patterns. The speaker emphasizes writing maintainable code by making strategic decisions about pattern usage based on actual needs rather than prematurely implementing complex architectures. He covers both preventative and reactive patterns, from code organization to scaling solutions.

Jason McCreary (JMac) presents data and insights gathered from Laravel Shift, an automated Laravel upgrade service that has processed over 8,400 Laravel projects. He analyzes common patterns, anti-patterns, and feature usage across Laravel applications, providing recommendations for better code organization, validation handling, event usage, and framework feature adoption.

TJ Miller presents a comprehensive talk on building and maintaining Laravel APIs, covering best practices from planning through implementation. He emphasizes the importance of documentation, resource responses, schema validation, and maintaining API contracts while sharing practical workflows and implementation patterns developed over years of experience building critical payment processing APIs.

The speaker presents a practical guide to understanding and implementing design patterns in Laravel applications. Starting with a story about a junior developer struggling with the Gang of Four design patterns book, he demonstrates how to make patterns more accessible by showing real-world implementations of the Adapter, Strategy, and Factory patterns using Laravel examples. The talk focuses on practical refactoring techniques and how to properly structure code using these patterns.

Bob Martin gives a talk about clean architecture, discussing how frameworks like Rails (and by extension Laravel) should not dominate application design. He emphasizes that web frameworks are just I/O devices and should be treated as plugins to the core business logic. He discusses the importance of proper architecture that allows deferring major decisions, separates business logic from delivery mechanisms, and enables easy testing. He also touches on the growing responsibility of software developers in society and the need for self-regulation through practices like TDD.

The talk focuses on code simplification techniques in Laravel applications. The speaker demonstrates several approaches including using view models to separate presentation logic from controllers, utilizing Blade X components for reusable form elements, and implementing query filters. The presentation includes practical examples of refactoring controller code and implementing custom components to make code more maintainable and reusable.

A comprehensive talk about design patterns in Laravel, focusing on three key patterns: Singleton, Observer, and Bridge. The speaker explains each pattern using real-world analogies (like pizza-making) and shows how Laravel implements them differently from traditional PHP implementations. The talk demonstrates how Laravel uses these patterns in its core functionality, including service containers, event systems, and database migrations.

The talk focuses on lesser-known but powerful Laravel features that analysis of Laravel Shift data suggests are underutilized. The speaker, Jase McCreary (creator of Laravel Shift), demonstrates various Laravel features including model casting, authorization gates, signed URLs, and helper methods that can make code more expressive and maintainable while reducing custom implementation code.

The speaker discusses how to write more declarative code in Laravel by refactoring common patterns found in controller actions. Using examples shared on Twitter as inspiration, he demonstrates how to transform verbose, imperative code into cleaner, more declarative alternatives using Laravel's built-in features like form requests, policies, mutators, and real-time facades. The talk focuses on practical refactoring techniques to reduce branching logic and improve code readability.

A live coding demonstration of Laravel package development where the speaker builds a gamification badge system package from scratch. The talk covers setting up package boilerplate, implementing badge functionality with tests, creating migrations, setting up facades, and explaining best practices for package development.

The talk discusses time-driven development and software architecture decisions, using real-world examples from building a user profile management system. The speaker emphasizes the importance of balancing proper software design principles with practical time constraints. They demonstrate how over-engineering can sometimes waste time, while strategic architecture decisions can save time in the long run. The talk includes examples of transitioning from a CRM-based system to a local database, and lessons learned from over-engineering a GitHub integration.

An interactive security demonstration where the speaker guides the audience through various security vulnerabilities in Laravel applications. The talk showcases common security issues like password brute forcing, insecure direct object references, cross-site scripting through markdown, and environment file exposure. The audience participates by attempting to hack a live demo application using their phones while learning about security best practices and common pitfalls.

Jake Bennett presents his first conference talk on implementing State Machines and the State Pattern in Laravel applications. He demonstrates how to refactor complex conditional logic around invoice status management into a cleaner, more maintainable state machine implementation using PHP classes. The talk walks through creating a state diagram, implementing state classes, and delegating behavior through a state machine pattern rather than traditional event-action controllers.

Matt Stauffer discusses how to effectively use Laravel in enterprise environments, focusing on practical considerations rather than justifying Laravel's enterprise-readiness. He emphasizes the importance of avoiding over-engineering, sticking to Laravel conventions, and managing technical debt while addressing the unique challenges of enterprise development like larger teams, complex requirements, and organizational processes.

Joel from the Laravel community shares his experience and strategies for getting unstuck when debugging. He presents four real-world debugging stories and extracts eight key principles for effectively solving difficult technical problems. The talk emphasizes that getting stuck is a normal part of development and provides practical approaches for working through challenging bugs, from paying attention to formatting to knowing when to take a break or ask for help.

This talk explores testing in Laravel with a focus on facades and test doubles. The speaker explains Martin Fowler's test double definitions (dummies, fakes, stubs, spies, and mocks) and demonstrates how to effectively use Laravel's built-in fakes for testing mail, events, jobs, and HTTP requests. The presentation emphasizes practical approaches to testing, showing how to avoid common pitfalls and achieve genuine confidence in tests rather than false confidence from incomplete assertions.

Luke Downing gives an insightful talk about learning lessons from Laravel's design and philosophy. He discusses how seemingly simple features like three-line comments and facades reveal deeper truths about software development. The talk emphasizes how Laravel teaches developers to balance rules and conventions with practical developer experience, using examples from routing, testing, and real-time applications.

A technical talk about software design patterns used in Laravel framework. The speaker covers several key design patterns including Iterators, Observers, Singletons, Facades, and Decorators, explaining how they are implemented in Laravel and their practical applications. The talk includes detailed explanations of each pattern's structure, purpose, and real-world examples from Laravel's codebase.

Matt Machuga gives a comprehensive talk about object-oriented programming in PHP/Laravel, focusing on proper object design, testing practices, and code responsibilities. He covers the history of OOP in PHP, explains key concepts like inheritance, traits, and polymorphism, and provides practical guidance on writing testable code while emphasizing the importance of proper object composition and responsible design patterns.

Ben Corlett discusses best practices for PHP package development, focusing on framework-agnostic design and the importance of maintaining package independence from specific frameworks like Laravel. He emphasizes using interfaces, avoiding framework-specific dependencies, and making packages reusable across different PHP frameworks while maintaining clean, maintainable code.

The speaker discusses his approach to building complex Laravel applications, focusing on architecture and abstraction. He shares his journey from basic MVC to more sophisticated patterns, emphasizing the importance of proper abstraction layers, service providers, and facades. He advocates for writing clean, maintainable code that distributes complexity across well-designed structures while maintaining a beautiful API surface.

Frank Diama discusses how developers can learn from other developers, frameworks, and programming languages. He explores different approaches to solving common problems, using examples from Python and JavaScript to demonstrate how their solutions can inspire improvements in PHP. He covers topics like event handling, promises, and variadic arguments, while emphasizing the importance of choosing the right tool for each job rather than trying to solve everything in PHP.

A comprehensive talk about bringing Laravel's best practices and components to legacy PHP applications through incremental improvements rather than complete rewrites. The speaker discusses how to modernize existing codebases by gradually introducing modern PHP practices, Laravel components, and external services while maintaining operational stability.

Kirk discusses a comprehensive approach to validation in Laravel 4 applications, focusing on separating validation logic from models and controllers into dedicated validation classes. He demonstrates how to handle different validation scenarios through use-case specific validation classes and how to leverage Laravel's exception handling system to cleanly handle validation failures.

A talk about reducing coupling in software systems through domain-driven design principles. The speaker discusses how to move beyond simple CRUD operations by using commands and events to decouple different parts of an application. He emphasizes the importance of using domain language in code, encapsulating business logic, and handling complexity through proper abstractions rather than relying solely on framework patterns.

The talk focuses on Test-Driven Development (TDD) and behavioral design patterns, particularly emphasizing the importance of object communication and mocking in software design. The speaker discusses how exposing object communications through tests can help identify design problems and SOLID principle violations. He argues that mocks should be used as design tools rather than just for test isolation, and presents several case studies showing how proper mocking practices can lead to better software design.

This talk by Esther Co discusses the ethics and practicalities of whistleblowing in technology, particularly focusing on responsible disclosure of security vulnerabilities. She presents the '3 Ds' framework (Discovery, Debate, Disclosure) and discusses legal implications, ethical considerations, and best practices for reporting security issues. The talk includes case studies like the Ashley Madison hack and DigiNotar incident to illustrate different approaches to disclosure.

The talk discusses software development costs from three perspectives: cost of introduction (writing new code), cost of change (modifying existing code), and cost of ownership (maintaining code). The speaker emphasizes the importance of understanding these costs when deciding whether to write custom code or use existing packages/tools, and advocates for only taking ownership of code that truly needs to be owned and changed frequently.

A comprehensive talk about PHP package development best practices, focusing on how to create and maintain high-quality packages. The speaker discusses beginner steps for package creation, intermediate tips for package management, and advanced concepts like decoupling and virtual packages. The talk emphasizes the importance of following standards, proper documentation, and making packages framework-agnostic.

The talk discusses how Test-Driven Development (TDD) has evolved into Specification by Example and Behavior-Driven Development (BDD). The speaker demonstrates this evolution by building a Wikipedia search feature using PHP Spec, showing how to write specifications before implementation, use mock objects, and integrate the solution with Laravel. The presentation emphasizes the importance of changing terminology from 'tests' to 'specifications' to better communicate intent and improve developer understanding.

The talk introduces the Lucid Architecture for Laravel applications, which is a pattern for organizing code in large-scale applications. The speaker explains how Lucid Architecture helps maintain clean code by organizing features, jobs, and services in a structured way. The architecture aims to solve common problems like legacy code, technical debt, and code organization while remaining performant and maintainable.

Jesse and Corinne from Vehicle share their experiences and best practices for running successful software projects. They discuss their approach to client relationships, project management, and team collaboration. Key aspects include weekly billing cycles, emphasis on discovery and planning phases, structured meetings, and maintaining collaborative relationships with clients. They also share insights on handling project pivots, managing multiple projects, and conducting effective retrospectives.

The talk discusses web accessibility, focusing on making websites usable for people with disabilities, particularly those who are blind. The speaker, whose mother is blind, emphasizes that accessibility benefits everyone, not just those with permanent disabilities. He covers semantic HTML, ARIA roles, and practical implementations for making web content accessible through screen readers and other assistive technologies.

A comprehensive talk about using Git effectively, focusing on writing meaningful commit messages and maintaining a clean commit history. The speaker discusses the importance of atomic commits, proper commit message formatting, and using Git's features like rebase and interactive staging to create a more useful and maintainable version control history.

The speaker presents an innovative approach to software architecture inspired by Bruce Lee's martial arts philosophy, introducing 'Bruce Lee Driven Development' (BLDD). The talk draws parallels between Bruce Lee's adaptive martial arts style and software development, encouraging developers to focus on simplicity, directness, and efficiency. The speaker emphasizes the importance of understanding core problems, recognizing value, embracing change, and experimenting with different approaches rather than rigidly following established patterns.

A comprehensive talk about code reviews that goes beyond basic code style discussions. The speaker emphasizes the importance of constructive feedback, proper communication techniques, and maintaining a positive team environment during code reviews. They introduce the 'sandwich technique' for giving feedback and discuss how to automate code style checks to focus on more meaningful aspects of code review.

A talk about the importance of user experience (UX) design in development, focusing on how developers can improve UX through better logging practices and thoughtful design choices. The speaker shares experiences from teaching technology in Indonesian villages to demonstrate how diverse user bases are, and provides practical tips for implementing better UX through Monolog logging and human-centered design principles.

The talk demystifies monads by explaining them as ordinary data types with specific operations and rules, similar to stacks and collections. The speaker uses practical examples in PHP/Laravel to show how monads are already being used (like Laravel's fluent syntax, JavaScript promises, and jQuery), and demonstrates how to implement basic monads like Maybe and Many to handle null checking and collections in a functional way.

This talk focuses on design patterns in Laravel, particularly exploring the Factory Pattern, Builder Pattern, Strategy Pattern and Provider Pattern. The speaker uses a pizza ordering system as a practical example to demonstrate how these patterns can work together to create maintainable, flexible code. The talk includes concrete examples of implementing these patterns in Laravel applications and explains how they can be used to extend framework functionality.

The speaker shares experiences from her time as a technical lead at an interactive agency, focusing on how to handle project failures and crises effectively. She discusses two main types of problems - project/people problems and technical issues - using real-world examples from her career. The talk emphasizes the importance of having proper incident response plans, checklists, and shame-free culture when dealing with failures, while also highlighting the value of clear communication and flexibility in project management.

A talk about improving web design for developers, using a step-by-step debugging approach similar to debugging code. The speaker walks through transforming a developer's personal website by systematically addressing color selection, typography, hierarchy, layout, and polish. The approach emphasizes that good design is achievable through methodical improvements rather than innate creativity.

A comprehensive talk on testing best practices in Laravel, covering 12 tips for effective testing. The speaker discusses various testing tools and techniques, from IDE configurations to test organization and quality checks. Key focus areas include TDD, automated testing workflows, and ways to make tests more readable and maintainable.

The speaker discusses moving from traditional API testing in Laravel to using API Blueprint specifications. He demonstrates how API Blueprint provides a language-agnostic way to define API structures using markdown, which can be tested using Dredd. The talk covers practical examples of implementing API specifications, using hooks for authentication, and organizing large APIs by splitting specifications into multiple files using Hercule.

Alex Bilby presents a comprehensive overview of the 12-factor app methodology and how it applies to Laravel applications. He discusses best practices for deployment, configuration management, and scalability, emphasizing the importance of containerization with Docker, proper environment variable handling, and stateless application design. The talk combines theoretical concepts with practical examples from his experience as a DevOps consultant.

An introduction to Domain-Driven Design (DDD) that focuses on the importance of communication between developers and domain experts. The speaker emphasizes that DDD is not about specific coding patterns but rather about understanding business domains, creating ubiquitous language, and establishing bounded contexts. He shares personal experiences working with legacy applications and explains how DDD principles can improve software development through better communication.

A thought-provoking talk about the responsibilities developers have regarding data privacy and security in the modern age. The speaker emphasizes how we've become too casual with handling user data, discusses the implications of permanent digital footprints, and provides practical advice for better data stewardship, including implementing proper protocols, checklists, and access controls.

A personal and practical talk about the journey of releasing software products, focusing on maintaining work-life balance while developing Laravel applications. The speaker shares experiences from his 20+ year career, discussing how to plan projects effectively, handle stakeholder expectations, and maintain mental wellbeing during development. He emphasizes the importance of starting with a minimum viable product (MVP) and not being afraid to fail or abandon projects when necessary.

This talk discusses moving beyond basic CRUD operations in Laravel applications, focusing on better ways to structure code using domain-driven design principles. The speaker emphasizes using ubiquitous language that matches business requirements rather than database structures, separating read and write operations, and implementing more meaningful actions instead of simple CRUD operations. He shares examples from large-scale projects and demonstrates how to improve code organization using commands and events.

A security-focused talk by a CTO from Helsinki discussing practical hacking techniques and defensive strategies in Laravel applications. The speaker demonstrates SQL injection attacks using SQLmap, object injection vulnerabilities through PHP stream wrappers and serialization, and privilege escalation risks when running Laravel scheduler as root. The talk emphasizes the importance of proper validation, keeping software updated, and understanding security as an ongoing process rather than a one-time task.

This talk discusses software estimation techniques, focusing on how to leverage uncertainty rather than avoid it. The speaker explains how to use range estimates instead of single values, different measurement scales (nominal, ordinal, rational, interval), and various techniques for improving estimation accuracy. He emphasizes that estimation is an iterative process of reducing uncertainty through observations and measurements.

This talk discusses software architecture principles, focusing on SOLID principles at the component level. The speaker explains how to design and organize components, manage dependencies between them, and ensure good architectural practices. Key concepts covered include component cohesion rules (REP, CCP, CRP), component coupling principles (ADP, SDP, SAP), and how to measure and maintain stability and abstractness in software architecture.

A talk focused on secrets management and security in web applications, particularly emphasizing the business impact of poor security practices. The speaker discusses the risks of storing credentials in clear text, the costs of data breaches, and presents HashiCorp Vault and AWS Secrets Manager as solutions for secure secrets management.

Shti Balasa gives a comprehensive talk about best practices for customizing Tailwind CSS, focusing on when and how to customize the framework effectively. The speaker emphasizes maintainable approaches to customization, discusses where to place customizations (CSS vs JavaScript config), and demonstrates how to create custom plugins and components while maintaining good developer experience.

The speaker demonstrates how to refactor a complex Laravel/Livewire component handling mortgage calculations into smaller, more maintainable pieces using SOLID principles and good design practices. Through several refactoring steps, he shows how to extract business logic into services, use DTOs, implement interfaces, and write proper unit tests while maintaining functionality.

Luke Downing presents a comprehensive overview of Pest PHP testing framework, demonstrating its key features like higher order tests, data sets, and expectations API. He showcases these features by building tests for a demo Laravel application called ParrotCon, explaining how Pest simplifies testing while maintaining elegance and expressiveness compared to PHPUnit.

A talk about learning important development lessons from Laravel's design choices. The speaker discusses how Laravel's ordinary and obvious approach leads to better developer experience, using examples like routing conventions and facades. He emphasizes how sometimes breaking traditional programming rules can be beneficial when the gains in developer productivity outweigh the theoretical drawbacks.

Christof Rülle shares his journey of managing and optimizing a large Laravel test suite with over 5,000 tests that initially took 50 minutes to run. He discusses the challenges faced and solutions implemented, including parallel testing, optimizing setup methods, and dealing with caching issues, ultimately reducing the test runtime to 5 minutes.

Bobby Balman from Hospitable discusses strategies for maintaining and surviving large Laravel applications. He shares experiences from managing a large-scale Laravel application processing 51 million jobs daily, emphasizing the importance of consistent code structure, proper testing, and following Laravel defaults. The talk focuses on practical approaches to organizing code in domains/modules while keeping things simple and maintainable.

A talk about Git version control, focusing on the speaker's journey from being afraid of Git commands to becoming proficient with advanced features. The speaker shares experiences working at different companies and explains core Git concepts like storage, branches, merging, and rebasing while demonstrating practical examples through a command-line demo.

The talk discusses how to effectively model business requirements using Laravel's Eloquent ORM while following domain-driven design principles. The speaker demonstrates how to create clean, maintainable code by properly encapsulating business logic, using domain-specific language, and avoiding leaky abstractions. Using an award management system as an example, he shows how to evolve from simple CRUD operations to more complex domain models while keeping the code aligned with business terminology and requirements.

The talk discusses structuring large Laravel applications using domains and improving frontend interactions using TypeScript. The speaker shares examples from Flare, an exception tracking application, to demonstrate how to organize code into domains for better maintainability. They also cover authorization handling and type safety between backend and frontend using TypeScript.

A comprehensive talk about testing JavaScript and frontend applications, focusing on making testing more manageable and enjoyable. The speaker covers various testing tools and approaches, from static analysis to end-to-end testing, with practical examples of how to implement them effectively.

Max presents his Laravel API Boilerplate project, which helps developers quickly build REST APIs. The boilerplate provides out-of-the-box functionality for common API features like CRUD operations, transformers, authorization, and case conversion between snake_case and camelCase. He demonstrates how to create API resources, handle relationships, and implement validation with minimal code while maintaining flexibility for custom business logic.

Jason McCreary presents 10 tips for creating maintainable Laravel applications based on his experience with Shift and 20 years of programming. He covers topics ranging from staying current with Laravel versions to proper testing practices, emphasizing code readability and framework conventions. The talk focuses on practical approaches to improve application maintainability through proper structure, dependency management, and adherence to Laravel's design patterns.

Marcus Moore presents a talk about behavior-driven development (BDD) in Laravel, explaining how BDD helps bridge communication gaps between stakeholders and developers. He shares his journey from working at a small school to an agency, where he discovered the need for better requirement gathering and testing processes. The talk covers the three stages of BDD - discovery, formulation, and automation - with practical examples using Behat and Laravel integration.

This talk discusses approaches to securing data and communications in software-as-a-service applications, particularly focusing on end-to-end encryption, zero-knowledge systems, and practical ways to protect user data. The speaker uses a banking/financial data example to illustrate concepts around encrypting sensitive information while still maintaining service functionality. The talk concludes with practical advice for incrementally improving data security in applications.

The speaker discusses strategies for modernizing and refactoring legacy PHP applications. He covers the challenges of dealing with old, poorly structured codebases and presents a methodical approach to upgrading them using the 'strangler fig' pattern. The talk emphasizes the importance of securing buy-in, implementing code standards gradually, and carefully migrating functionality to new systems while maintaining business operations.

A talk about what makes a 'super developer', challenging common perceptions by arguing that the best developers are those who are 'slow' (thoughtful), 'selfish' (maintain work-life balance), 'lazy' (avoid repetitive code), like to argue (engage in healthy debate), and write 'bad' code (embrace imperfection and learning). The speaker emphasizes the importance of personal wellbeing, setting boundaries, and avoiding toxic hustle culture in development.

Nuno Maduro presents Pest PHP, a modern testing framework for PHP. He demonstrates its elegant syntax, improved test output, and expectation API compared to PHPUnit. He then introduces a new stress testing plugin called Stressless that helps developers test application performance under load. The talk includes live demos of both Pest's core features and the new stress testing capabilities.

James Brooks presents a talk on documenting Laravel APIs using Scribe, demonstrating how to automatically generate comprehensive API documentation directly from code annotations and comments. He shows how to group endpoints, add request/response examples, handle authentication documentation, and discusses hosting options including using bump.sh for enhanced documentation features.

Josh Hanley, a core maintainer of Laravel Livewire, presents best practices for building maintainable Livewire applications. He covers various architectural approaches including page components, computed properties, form objects, and action classes. The talk focuses on code organization, naming conventions, and strategies to keep Livewire components clean and testable.

This talk focuses on accessibility in backend development, challenging the common perception that accessibility is only about frontend concerns. The speaker discusses how accessibility affects developers themselves, including considerations for different coding styles, development processes, and tool selections. He emphasizes that accessibility isn't just about disabilities but includes making code and processes accessible to developers with different experience levels, language backgrounds, and working styles.

Greg, the director of Technology at IC plant, discusses seven key habits that create high-performing software development teams. He explains how teams can maximize value delivery while minimizing toil through practices like working in small steps, maintaining zero bugs, continuous deployment, simple solutions, pair programming, and fostering a learning culture. The talk includes data from Google's DORA report showing how high-performing teams significantly outperform others in deployment frequency, lead time, and incident recovery.

A comprehensive talk about web accessibility testing and how to build better habits around it. The speaker discusses various tools and techniques for testing accessibility, including screen readers, keyboard navigation, and color contrast tools. The talk emphasizes making accessibility testing more approachable by breaking it down into manageable checklists and establishing regular testing habits.

Sam, a CTO at Custom D, discusses the evolution of deployment practices and how to achieve high DevOps maturity. He explains how organizations can move from monthly deployments with high failure rates to continuous deployment with minimal risk through incremental improvements, automation, and feature flags. The talk covers practical strategies for implementing modern deployment practices, including handling legacy code bases and getting organizational buy-in.

A talk about building life-critical systems with Laravel, focusing on the speaker's experience developing emergency services applications. The speaker shares six key principles: keeping things boring/simple, knowing your code intimately, embracing exceptions, minimizing dependencies, training in realistic environments, and having critical testing partners. The talk emphasizes practical approaches to building reliable systems rather than using cutting-edge technology.