BADCamp 2019


BADCamp is many things: a free technology conference, a gathering of friends and like-minded folks, an introduction for those wishing to enter into the world of web technologies, and a celebration of the greater Drupal community. For thirteen years, BADCamp has brought thousands of people from all over the world to gather for four days in the Bay Area to share, teach, learn, network, and socialize around the Drupal content management system, open-source software and the greater technology ecosystem that surrounds them.

Video Sponsor(s) / Provided by
Curated Videos
Branislav Bujisic

Drupal 7 has been there so long, and it offered us unprecedented flexibility to build some pretty huge projects -- special kind of beasts that have nothing to do with the original "Drupal-as-a-CMS" paradigm. Think about Drupal sites that behave as OAuth2 servers; or sell content access, or prorate prices and bill them monthly; or news portals that are also exposing the API's for popular mobile apps; or membership databases of really big organizations. Sometimes, these projects would be so big and so crucial to our businesses that there would simply be too much disruption if they went offline.

But Drupal 7 is getting closer to its end of life. We have good migration scenarios for most of the use cases. However, the above giants are marginal cases which cannot simply be migrated to Drupal 8. And even if they could — that may result in building a new giant which would have to be killed once again at Drupal 8's end of life. Sometimes, a transition to something service-oriented may make more sense.

This session suggests a strangler application pattern in a Drupal 7 project. Martin Fowler describes the strangler application as “…a new system around the edges of the old, letting it grow slowly over several years until the old system is strangled”. In our PHP/Drupal realm, that means:

decoupling the frontend of a Drupal 7 project;
placing a middleware API proxy between the frontend and Drupal;
finally replacing individual parts of the old system with the newly developed ones
This approach promises zero downtime and makes no assumptions on what will be the resulting tech stack. The decoupled frontend can be a GatsbyJS project, or a React app, or even a static HTML served from the middleware. And the middleware itself can be a NodeJS/Express app, or a Golang API proxy, or something third. The backend can be replaced with a Drupal 8 monolith, or multiple Drupal 8 projects, or with a full-blown microservice architecture.

The sweetest part of the pattern is that even if you make an error in the architecture of your backend, which will require serious refactoring, you will be able to correct it without a downtime.
Dan Ficker

You have created a beautiful, shiny new web site or a stellar partner has created one for you. It is ready to launch and usually someone just hands it over to a server administrator or the DevOps team. Instead, this time you are the launch team. Don’t panic. This session will give you the knowledge to understand what you need to make it a smooth launch.

To launch, you need various pieces of information about domains, DNS, SSL and more. You then have to set these up correctly. If you do so, you should have a smooth launch of your new site.

This session is for any developer or website stakeholder who wants to better understand how the Internet works and how visitors come to and interact with the website. There is not any code, but there will be talk of how the Internet works and resources on how to configure a site to be secure and serve visitors well. To explain domains and DNS, the session will get a bit nerdy about networking, but it should be accessible to folks who do not work in IT.

Topics Covered
Gathering domain ownership information.
Setting up DNS records or getting DNS changed smoothly.
Requirements and recommendations for SSL encryption and implementation.
Evaluation of hosting requirements and hosting options.
Considerations from moving from an old site to a new site.
Irina Zaks

This year we celebrate 4 years since Drupal 8 was released. A one-click upgrade from older versions is one of its greatest features, thanks to the Migrate module being in core. While Migrate is powerful, it lacks a good UI. In contrib, we have Feeds for importing content. This module does have a UI perfectly tuned for site builders, but it defines its own import framework. Wouldn’t it be great if the two frameworks could be combined together?

This would be a win-win solution for everyone, because:
- Developers would only have to maintain one import framework;
- Site builders could use the power of Migrate without having to write code;
- Content managers gain the flexibility to import their content without the need to go through another round of development effort.

Two years ago, the maintainers of both import frameworks discussed the idea and that eventually resulted into the Feeds Migrate module being developed.
Today we will demo what has been completed, what still needs to be done and how everyone in the Drupal community benefits from this effort.

We will also talk about Drupal Community culture that powered development of module with zero budget.

This session will be presented also at DrupalCon Amsterdam.
Daniel Sipos

In this session we are going to explore some advanced techniques for building and running migrations.

Sometimes you can define your migrations in a single file, run them, close your laptop and go grab a beer. But let’s face it, most other times things are bit more complicated. What we will talk about in this session are some of the cases in which you need to get a bit creative. Such as standardise your source data. Transform it before it gets imported. Or build dynamic migrations.

An important example we will look at is how we can migrate multilingual content from various types of sources.

A general run-down of what we will cover in the session is as follows:

* The basics of setting up a migration and how it actually works under the hood
* (Migration) plugins and plugin derivatives
* Migration templates
* Use case: migrate nodes with translations
Ruby Sinreich
Tara King

As Dries Buytaert discussed in the DrupalCon Seattle keynote, open source has a serious diversity problem - and that includes our own Drupal community. We are people who care about fairness for all, and yet inequality persists. What can we do?

Without understanding a problem, we can’t develop effective solutions. So in this session we will introduce some concepts to help us see how bias and inequality persist in spite of the best intentions. And we’ll talk about what we can all do to help the Drupal community live up to our open values and global reputation.

While it's impossible to fix decades of gender and racial inequality with any single action, we must do better. Those in a position to help have an obligation to improve the lives of others. We should not only invite underrepresented groups into our Open Source communities, but make sure that they are welcomed, supported and empowered.
- Dries Buytaert

Drupal Diversity & Inclusion (DDI) is working to make the Drupal community more equitable and more successful. The group of volunteers was founded in 2016 and works to create space for important discussions about the Drupal community and for initiatives that support historically-marginalized communities and further their inclusion in the Drupal project.

This talk, presented by members of DDI’s leadership team, will discuss some of the issues facing the Drupal community, as well as what we in the community can do to address those issues, including providing a safe discussion place for marginalized folks, offering a jobs board, building a resource library, offering workshops to help under-represented people speak at Drupal events, connecting contributors with mentors, providing leadership and advocacy on issues of diversity and inclusion, and more.

We can make the Drupal project better and stronger by making the Drupal community a place where a wider range of people can participate and contribute their knowledge and skills.
Cody Kraatz
Jordan Thompson

Santa Clara Valley Transportation Authority (VTA) is an independent district that provides sustainable, accessible, community-focused transportation options that are innovative, environmentally responsible, and promote the vitality of the region. It provides bus, light rail, and paratransit services as well as participates as a funding partner in regional rail service.

As the county’s congestion management agency, the organization is also responsible for countywide transportation planning, including congestion management, design, and construction of specific highways, pedestrian and bicycle improvement projects, as well as the promotion of transit-oriented development.

To deliver the experience its customers want and to keep them coming back, VTA needed to deliver a state of the art, reliable, open-source, mobile-first web experience, while still endorsing Transit for things an app does best.

It would need to break down silos within its own organization to ensure that stakeholders understood the new website would be based on input and feedback gained from its primary customers - transit riders, people affected by or interested in transportation projects, and other engaged community members.

To accomplish its business goals, VTA hired Drupal development firm Digital Echidna and engaged Acquia Cloud service, investing in a year-long site redevelopment that would cross all VTA departments, and include input from the public.

This process included the build of a minimum viable product (MVP) for beta testing, solicitation, and collection of customer feedback, and several product iterations, before the launch of a customer-focused solution in 2019.

The Case Study will be collaboratively presented by VTA and Digital Echidna and will cover topics such as:

Business Goals and how these goals have been met/will be met.

Increase user satisfaction, improve interaction

Deliver a mobile-first, responsive, user-centric experience

Deliver on an open-source technology platform

Leverage transit industry standards

Conduct an iterative development approach with continuous improvements

Challenges with the current website and throughout the project (if any).

1. VTA’s legacy website better served its internal audiences than it did primary customers of VTA and failed to support its largest segment of online traffic - mobile users.

Overview of statistics and research to support decisions for change

Understanding where the Customer Experience gaps were and formulating a plan

2. Producing a great web experience in a government and Transportation context (limited resources, many stakeholders, not always the most technologically advanced stakeholders)?

Building on Open Data standards (GTFS and GTFS-realtime)

Reimagining what "content" is, and how to handle it

How we worked in collaboration with Digital Echidna and our stakeholders to create such a great digital experience

Approach taken to overcome the challenges and deliver a great digital experience for our customers

Strategy and Implementation Plan


Processes - UX approach

Technology - Drupal/open source


User/Customer feedback

Adjustments based on feedback

Successful launch

Where are we now

What's next on our Digital Roadmap
Drew Gorton

Those of us planning, designing, building or supporting Drupal for others are increasingly working for people who see that work through the lens of Marketing. This session will start by looking at the big picture of what's happening in the web market (Wix, WordPress, Sitecore, etc.), where Drupal fits today and how that evolution involves marketing professionals. Put another way, if Drupal is becoming the tool for Ambitious Digital Experiences, those experiences are paid for by Marketing budgets.

If you’ve come to Drupal via tech ("Come for the code" as we like to say) you might not have an intuitive grasp of the language and concerns of marketing professionals. This session will explain what Marketers do (it’s different than Sales!), how they do it and what matters to them. Come to this session for an overview of Drupal in the web market, a primer on marketing terms (MQLs, CTAs, Funnels, ...), marketing needs (NNN, CTR, Conversions, …) and competing marketing technologies (there are zillions!).

You will leave this session with a better understanding why marketers matter to Drupal professionals, what motivates our marketing colleagues, what they care about and how to make your work more relevant and valuable to them.

Learning Objectives & Outcomes

Come to this session for a primer on marketing terms (MQLs, CTAs, Funnels, ...), marketing needs (NNN, CTR, Conversions, …) and competing marketing technologies (there are zillions!). We’ll start with the big picture and dive down into how things fit together and why they matter.
Michael Lander

For many Drupal 8 users, image display begins and ends with Drupal core's image styles. In this session we will look at a recipe of core and contributed modules that can push this further to support better performance across devices and browsers. We will start with a brief overview of image styles and responsive images. Then we'll move into image compression and optimization, with an emphasis on the how and why of using various contributed modules together. We will also look at how we can support Google's WebP for even better image quality and optimization for most modern browsers.

The walkthrough will include the following modules:

Image(core) - Provides image styles and basic compression using image toolkits.
Responsive Image(core) - Implements support for HTML5 Picture elements, using defined breakpoints and image styles.
ImageAPI Optimize(imageapi_optimize) - Enables advanced optimization options, including additional binary support and third parties in the form of optimization pipelines.
ImageAPI Optimize GD(imageapi_optimize_gd) - Provides similar GD toolkit compression as Drupal core, but in the form of a ImageAPI Optimize pipeline.
ImageAPI Optimize WebP(imageapi_optimize_webp) - Enables you to derive a WebP copy of an image, and additionally provides a submodule for responsive image integration.
Additionally, we’ll briefly touch on some additional modules in the ecosystem, including: ImageAPI Optimize Binaries, Kraken,, Blazy, Lazy-load and more. You will leave this session with an understanding of how to implement these tools on your site today, as a solution that will work across standard image fields, Drupal core Media, and Media Entity solutions.
Kevin Bridges

As microservices and decoupled architectures continue to mature it becomes increasingly important to be able to work efficiently between local and live environments across the entire stack. What does it take to build a decoupled interface against a Drupal backend and how can we share the work with others?

Decoupled Drupal does not remove the challenges of running a local development system or deploying your work. In this session, we'll explore an example workflow that includes local development of a decoupled Drupal Umami site with a Gatsby front end. We'll use DDEV as the building blocks to manage our Drupal services from team-based local development through a modern JS application deployment.

When the session begins you should have a basic understanding of decoupled concepts and a strong desire to build. You'll leave with a solid idea of how you might simplify handling decoupled projects from development to deployment and how you can try it at home.
Amber Matz

What is the state of Drupal 9? What can I do now to prepare for the upcoming release? Learn how innovation happens in Drupal 9 through semantic versioning, scheduled releases, and experimental modules and why a new major release is still necessary. Hear about the various processes that are taking place to prepare for Drupal 9, including deprecation processes, and which major 3rd party APIs will be updated. Finally, learn what the support time frame for Drupal 7 sites will be and checks you can perform now to ensure Drupal 9 compatibility for a future migration.

By the end of this session, you should have a better understanding of why Drupal 9 is being released, the processes and planning currently taking place, and how to prepare for this upgrade.

Would you like to learn about layout builder in core? Are you feeling excited but a bit intimidated to start using it yourself? We've got you covered! Come to the session where you can become a layout builder ninja in just one day! You will get to learn tips and tricks and all of the gotchas from modules you should be using, building techniques, multilingual layout builder tips and performance to making it better for your editors and site-builders to use. We also will show you inspiring examples of real world projects to get your creative juices going!
Aurora Morales

With new threats constantly emerging, how can website owners protect themselves and their business? In this session, we will cover this crucial topic for SEOs and share several demos of these threats, plus how they can be prevented. Find out what Google is seeing in hacking trends, Google’s view on what HTTPS does (and doesn’t do), and how to best address a hacked site.

Attendees will learn how to protect against SQL injection attacks, sanitize user generated input, and come away with other practical tips that can immediately be implemented to secure their sites.
Tim Broeker

Drupal is a shining star in the world of content management systems, with a remarkable 20 year history and a proven ability to power some of the world’s largest brands and websites. WordPress has enjoyed even greater success, and now powers more than 30 percent of the entire web.

Collectively, we have become extremely great at what we do.

But in just the last 5 years, the landscape has shifted dramatically in ways that are fundamentally changing how and what we build.

Monolithic platforms like Drupal and WordPress are no longer the obvious or default solutions. It is now just a matter of time before MOST websites and web applications are built on something other than a traditional, server-based content management system.

This session will explore why and how quickly this change is happening, who it will affect, what you can do about it, and why Drupal still matters in this ecosystem (perhaps more than ever.)

We will explore:

Who will be most affected by this change
How quickly and why these changes will happen
The reasons everybody is so excited about JavaScript, Gatsby, and the JAMstack
Why things that were very hard even 2-3 years ago are now easy
Steps you can take to get yourself started today, and why Drupal still matters
The truth is that we are no longer building websites.

The backend has been solved, and is now fully commoditized. Our job today is to create amazing experiences that help our users navigate an increasingly noisy barrage of devices, networks, content, and tools.

Drupal and other backend systems may play a central role in this new world, but they are now a secondary concern.

Speaker info:

Join us on a journey into this new frontier through the lens of a seasoned Drupal developer and technical architect who continues to make his own mistakes and learn his own lessons on the path toward building a better web.

Tim Broeker is the technical director and co-founder of Electric Citizen, a digital agency in Minneapolis, MN. He has been building the web since 1994 and has deployed large, enterprise grade projects in more than 16 distinct content management systems. He has presented recently at Twin Cities DrupalCamp (2019), the MN Council of Nonprofits Technology Conference (2019), BadCamp (2018) and DrupalCon Nashville (2018).
Shawn DeArmond
Mark Miller

DevOps, CI, Build, Test, Deploy! There are a lot of different components flying around this buzzword-compliant practice. It’s hard to know where to start. (Spoiler: always start with low-hanging fruit!) But the promises are very attractive: Fewer bugs, faster deployment, greater confidence in your changes.

Learn practical tools and workflows from those of us already in the trenches. We will cover:

Identifying the areas where automation will make the biggest difference

Continuous Integration tools and services such as CircleCI, ProboCI, Bitbucket Pipelines, GitHub, and GitLab.
Automated testing techniques such as End to End (Behavioral, Functional, etc), and Visual Regression.
Automated testing tools, such as Cypress, BackstopJS, Behat, PHPUnit, and more.
Remember, it's a journey, not a destination.

Previous Knowledge
This session assumes you have some knowledge of application development, but is also applicable to project managers and product owners who are interested in realizing increased stability of your systems.
Lily Berman

This session is for anyone who has ever felt overwhelmed by a giant and ever-expanding list of tasks and priorities. How do you keep them organized and prioritized to ensure you’re completing what’s most urgent and important, but also that nothing is slipping through the cracks?

As a manager (both project and account) in a variety of Drupal agencies, Lily has envied the workdays of designers and developers who focus for hours on a single task. In her world, a workday can often be split into 20+ time entries. Yikes! To survive, she has tested multiple frameworks and adapted a solution that works wonders for her. Come see the evolution of what she considers to be the perfect (for now) personal tasking system.

In this session, you will learn the:

Merits and limitations of digital tasking tools like Trello, Asana, and Jira
Magic of a pile of post-its (and when they’re at their best)
Bullet journal task list framework, and how it can be adapted to meet the needs of our industry
Marvin Oey

There will be no foolish wand-waving or silly incantations in this session. As such, there are few who appreciate the subtle science and exact art that is configuration management. However, for those select few who possess the predisposition, this session will teach you how to bewitch the code and ensnare the configuration. This session will tell you how to bottle updates, brew features, and even put a stopper in update errors. Then again, maybe some of you have come to BADCamp in possession of abilities so formidable that you feel confident enough to not pay attention!

Implementing a workflow can be elusive and oftentimes becomes a timesink of issues. In this session we will go over key concepts, common pitfalls like the UUID mismatch, content vs configuration, and tips and tricks.

Topics will include:

Using the Drupal UI
Using drush and touch the key config commands
Defining directories in settings.php
Using Configuration Split
Environment and site specific configuration setups
Different types of workflow
Configuration management in Drupal can be complex and some topics are technical,but the goal is to remain friendly for beginners while providing a nice refresher and good “lessons learned” and “gotchas” for experienced developers. No coding or programming knowledge is required. However, you’ll probably pick up a thing or to on drush.
Configuration management in Drupal can be complex and some topics are technical, but the goal is to remain friendly for beginners while providing a nice refresher and good “lessons learned” and “gotchas” for experienced developers. No coding or programming knowledge is required. However, you’ll probably pick up a thing or to on drush.
Geoff Appleby

If unexpected inline JavaScript was added to a WYSIWYG field on your site, would you know? If one of your JavaScript dependencies were altered to harvest sensitive form data, could you prevent it?

Content Security Policy is a new layer in web security to protect your site and your users from security and privacy risks such as cross site scripting (XSS), content injection, and data exfiltration. The Content-Security-Policy module is able to leverage Drupal 8’s libraries system to make this tool more easily available to every Drupal site.

This session will cover:

The most prominent risks and the Content Security Policy options available to address them.
The current state of the Content Security Policy spec, and current browser support.
The legacy headers that Content Security Policy replaces.
How to safely implement and monitor the effectiveness of a policy.
The roadblocks current modules, frontend libraries, and third-party services present.
Further hardening techniques for complex sites.
Additional browser features for improving security and monitoring end-user issues on your site.
Useful for site builders and developers, attendees should walk away from this session with the core knowledge required to implement and monitor a Content Security Policy for their website.
Bob McDiarmid

Just as the design process should seek to create something perfect and useful for the users and the client, so should the documentation. Documentation can be the first set of deliverables within an agency process to become outdated, stale, or redundant—mainly because they are dismissed as unimportant or left to a lackluster team to plod through begrudgingly. This doesn't need to be the case if we throw out what we think documentation means and seek to find more meaningful ways to integrate the process of documentation.

Documents can be exciting, inspiring, and creative forms of expression. Documents can be "living" data, intended to be evolving road maps that can empower a client team long after the vendor has left and the project deliverables have been handed over. Documents are often the foundations that survive the longest and inform the next iteration of thinking. Documentation, when done successfully, can keep forward momentum in place and keep the team focused.

What I propose is adding a 'Documentation Content Type' to your workflow! Using Content Access Rules, you can make it available to only your authenticated users. That way you can have user 'how to' documentation and technical notes from releases and component builds right there in your Database.
Mauricio Dinarte

Drupal is an extremely flexible system. To achieve this, various layers of abstractions were built into it. A lot of concepts were created to explain these abstractions. Unfortunately, they are not always intuitive. This session aims to explain the basic building blocks for assembling a Drupal site and how they relate to each other. Many examples will be presented to help you understand Drupal and why it is so powerful.
Learning Objectives & Outcomes:

By the end of the session, attendees will understand:

* What is a node?
* What is a content type?
* What are fields and why are they useful?
* What is a block and what can I do with it?
* What is a view?
* How are users and permissions managed?
* What is a module and its purpose?
* What is a theme and how can it change the look and feel of my website?
Michael Hess

This session will cover a topic near and dear to our hearts: How to juggle multiple complex IT projects without losing our balance. We’ll get real about distractions that we cause ourselves through unexamined habits or suboptimal work practices, and we’ll talk about how some basic Agile principles can support better work-life balance. We’ll also tackle how to recognize some systemic issues in a technical work environment, such as technical debt, and make a connection between small choices in our daily work-lives and big problems that snowball over time. This session will be fun, practical, and a little bit cathartic. Participants will leave with concrete examples of what they can do in their own organizations to increase the quality of work and the happiness of their employees.
Anthony Horn
Shawn DeArmond

For me it all started with a single process, client engagement. How do we create a system for on boarding clients, gathering requirements, accurately estimating work, and executing projects on time and on budget? In the beginning the process was in our heads and merely a product of conversation. It would evolve over time from a set of bullet points, to a series of pages, and eventually mature into a system with structured meetings, branded slide decks, precomposed meeting minutes, and ready to deliver assets for each step of the way. Like any healthy process it continues to evolve and we continue to find ways to improve it.

As we look to the future and begin developing other offerings the need for great processes continues. Come hear about our experience building processes for web development and UX and our plans to continue building successful processes in the future.
Gerardo Ramirez

Attribute Driven Design or ADD for short, uses the approach of defining a system architecture with the idea that the design process will be based by the software quality attribute requirements. ADD follows a recursive process in which the following activities are utilized: Plan, Do, and Check. In the Plan activity, software quality attributes and constraints related to design, are considered so that the correct elements are chosen to ensure the architecture can meet the requirements. In the Do, the elements are created to meet the quality attributes and function requirements of the system. Lastly in Check, the results of the design are analyzed to ensure the requirement of the system are satisfied. The process goes through a recursive process until the entire system has an architecture that meets all the requirements.

In this session we will dive into the 7 steps of Attribute-Driven Design and discuss how Drupal makes it easy for software architects to satisfy business requirements using ADD.

Confirm there is sufficient requirements information
Choose an element of the system to decompose
Identify candidate architectural drivers
Choose a design concept that satisfies the architectural drivers
Instantiate architectural elements and allocate responsibilities
Define interface for instantiated elements
Verify and refine requirements and make them constraints for instantiated elements
Dwayne McDaniel

In a world of endlessly approaching deadlines and pressure for always better results, who has time to do a retrospective? It turns out, successful teams do. Undertaking the necessary discipline it takes to develop the habit of this part of the Agile process does take effort but the end results are well worth it.

For a lot of teams that try, these end of sprint meetings can quickly turn into personal anecdote sessions and become completely based on 'gut feel' that is just a painful step that does not feel like it accomplishes anything valuable.

What if I told you there could be another way?

By following some very simple to implement practices, you can quickly base these retrospectives on real data and fine tune as you iterate. Understanding your data is the single most critical step any marketing or content delivery team can undertake. No miracle cure here, but instead, a recipe for better communication, clearer goals and how to go from 52 pickup to Magic the Gathering in a shorter time than you realize.
Nearly every new project focuses heavily on the flashy design and fancy tools it'll make for its visitors. So much focus is driven into the site user's experience to make it intuitive and pleasant, but in many cases this ignores the users that will visit the site more than anybody else: the content editors.

The topic of improving the editorial experience in Drupal has gotten much more attention in recent years through core initiatives and distributions like Lightning and Thunder exploring how to improve the administrative interactions. Making a user-friendly site admin doesn't require dedication at the level of a core initiative or distribution; through the use of existing contrib modules, some best practices, and a bit of consideration all the sites you build or manage can be intuitive and helpful to anyone logging into it with minimal added effort or risk.

Level of Knowledge
Content editor: Attendees interested in learning how forms could be improved even if unsure how to do so personally are welcome.
Site-builder: Attendees should be comfortable with installing modules and site-building configuration throughout Drupal.
Topics to be Covered
Principles of a good administrative experience
Best practices in Drupal forms
Contrib modules to improve your admin UX
Attendees Will Leave With...
Guiding principles to apply to any forms or admin experiences they encounter
Resources to reference for common UX best practices
A toolbox of modules to improve new and existing sites alike
This session made possible by Forum One.
Lindsey Gemmill

This talk explores common myths between design and development, and I’m here to bust them!

Is this you?

- A designer wondering what happens to your beloved mockups after handed off to the development team

- A developer having nightmares about the intricacies of design and functionalities seeming way off base of budget and scope

- A project manager watching from the sidelines wondering how this process can be improved

The answer to smooth project workflow has been right in front of us the whole time...collaboration! With the current state of agile workflows, it's important to remember that full team involvement from start to finish will eliminate many unknowns in projects.

We'll walk through the ins and outs of:

- Collaborative Commitment
- Design Workflow
- Development Workflow
- Setting Expectations / Project Planning
- Winning!

When we align design and development as one collaborative unit projects can really take flight. So, can we all just get along? Of course we can! Join me in exploring the common myths and working through improvements together.
Branislav Bujisic

So you learned the importance of tests. You also learned that they are made pretty simple with Drupal’s PHPUnit framework. You may have even invested some time to set up behavioral tests using Behat Drupal Extension. Now it’s time to bundle all the testing together in a nice automated pipeline.

CI promises faster code review and fewer regressions on each deployment. It used to come with a high price: the need to set up Jenkins, Apache Ant, configure jobs and whatnot. It was a relatively simple task for ops people, but not for the PHP developers. So we’ve got some cloud-based CI tools, which are great, simple to set up, free for open source projects, but tend to get pretty expensive for the rest.

This session proposes a cheap and easy-to-set-up alternative. It will demonstrate:

Using GitLab server to host your own Git repositories and build powerful CI pipelines;
Automated code testing for every single merge request, which saves lots of time for code reviewers;
Automated deployment to environments for human review;
One-click deployment to the production environment;
Thinking outside of the box to optimize the CI workflow.
The best thing about the proposal is that it will be entirely up to you how complex you want it to be: start simple and add new steps to the build as you climb up the learning curve.
Local Drupal development can be tricky, especially with so many tooling choices. Having an environment that works for you is important whether you're a developer, tester, designer, or any sort of stakeholder. In this session, we'll review a few of the tools available (there are 37+ for Drupal at last count), their features, and meet some of the folks who build and use them.

This will be a panel discussion. Possible topics:

Drush and Drupal Console / WP-CLI support
Remote host support
Pre-made configurations
Custom configurations
Integrations with other services
On-going support
PHP options
Windows, MacOS, Linux support
Integration with hosting platforms
This will be a moderated panel with guests TBD.
Benji Fisher

While working on a project for Pega Systems, I had to deal with documentation organized into books, and some of the books had thousands of pages. Each page had a navigation menu listing every page in a large tree structure (nested HTML lists). The tree was collapsed, with just enough branches expanded to show the current page.

That's a lot of markup: UL and LI and A, oh my! Did I mention thousands of pages?

Generating that markup took a lot of work: database queries, PHP processing, theming ...

This talk will explain how I leveraged the cache system in Drupal 8, so that terrible, horrible, no-good page-load times became merely bad. The story has something for everyone:

A few lines of jQuery
A Twig template
A render array
Cache keys, cache contexts, and cache tags
Some SQL queries to show what is going on
Slides for this presentation (on GitLab Pages):
Chris Greatens

Every developer has been there: fresh out of school, new to the field, or using a new technology. There is a lot to know to successfully build Drupal websites. To be successful, developers learn technical skills in school or from websites and books. Applying those skills in the real-world is not always straightforward. In addition, soft skills are equally as important to being successful in this field and are often neglected.

As a developer that has been in the industry for almost a quarter of a century, I have accumulated a list of tips and tricks that has helped me be a successful developer and helped me grow my career from programmer to technical lead to architect to leading a Drupal practice.

In this talk, I will discuss what I have learned related to:

Being a valued team member

Partnering with clients (internal and external)

Being an efficient and effective Drupal developer

Effectively debugging problems

Growing yourself as a developer


Each attendee will come away with tips and useful practices to help her be a more effective Drupal developer, a more valued teammate, and ideas on how to grow as a Drupal developer.
David Needham
John Nguyen

The skills that are required to be a successful Project Manager encompass a great many things, and the expertise you acquire can be applied universally across every industry and most job roles. They're so broadly applicable that you can develop the skillset needed even outside of the workplace in everyday life... Like by playing Board Games! In this session, we'll identify some of the core competencies for a Project Management, and suggest Board Games that leverage these concepts which you can play to level up your Project Management Skills!
Greg Anderson

Drupal has leveraged Composer to manage its internal dependencies since version 8.0; however, the way that Drupal has been using Composer is unconventional. Our unconventional hybrid approach has allowed a loose continuity between managing codebases using Drupal 7 methods while simultaneously enabling more modern Composer based workflows. However, the modern Composer based approach was incomplete and unofficial, requiring third-party tools and examples such as drupal-composer/drupal-project. Because of the lack of a clear standard way of doing things, many sites found themselves in difficult to solve dead ends, or used obvious, but in hindsight incorrect choices to manage their site.

Presently, the Composer in Core Initiative is changing the way that Drupal uses Composer. New tools and new release scripts will make it more natural for Drupal sites to use Composer to manage their modules and other dependencies. Existing site management techniques, such as download and untar and drush pm:update, will continue to be supported for a time, so existing sites will not be forced to convert right away.

This session is intended for users who are currently managing a Drupal 8 site either with Composer or with Drush pm:download and pm:update. Topics covered will include:

- Why are we using composer, anyway? What’s the value?

- How should a new Composer-managed site be created using the latest tooling in Drupal core?

- What is the path forward from current sites to Composer-managed sites under the new system?

- How does scaffolding files differ in Drupal core compared to how it was done with the third party tooling (and what is scaffolding, anyway)?

- How is the way that Drupal tarballs are generated changing, and what is happening with the wikimedia/composer-merge-plugin (and what does Wikimedia have to do with Drupal, anyway)?

- Why does Composer sometimes have a hard time updating to a newer version of drupal/core?

- What sort of things are planned for Drupal and Composer in the future?

After attending this session, users will have a clearer understanding of the vision for Composer use in Drupal core, and what their options are for using Composer with their own sites moving forward.
Stephen Lucero
Rob Powell

Drush cr… drush cr… drush cr!!! We all know the scenario where you’ve made a change to the site, but when you load the page it just doesn’t seem to show. Oftentimes the solution is to clear your cache and move on, but why is that?

In this session we’ll explore how that cache is built and used. What determines when a page can be cached, and how does Drupal know when to rebuild it? How does Drupal know when to rebuild parts of a page without rebuilding everything?

Drupal 8 introduced a whole new methodology for caching: Cache tags and contexts. Using and maintaining these effectively will make your life easier and your clients love you. We will go over real life examples and show best practices to keep your caches up to date.

Level of Knowledge Needed
Attendees should be comfortable with back-end development and/or theme-level development using render arrays.

Topics to be Discussed
Throughout this session we’ll explore:

Caching layers in Drupal

Existing cache contexts and tags

Maintaining cache data throughout rendering

Caching during development

Session Takeaways
Attendees to this session will walk away with:

An understanding of how cache tags and contexts are used in Drupal 8

A view into Drupal’s rendering process and how caching data bubbles through the render caches

A framework of questions to determine when cache tags or contexts are needed

Helpful modules to use to drive your caching efficiency further

This session made possible by Forum One and Mediacurrent.
André Angelantoni

After years of preparation and work, Layout Builder has landed in core and it promises a new way to make pages in Drupal. Will Layout Builder take over from the long pedigrees of Display Suite, Panels and other page layout systems? Is it already on the way to doing that?

In this session, we will describe how we used Layout Builder on a major new Drupal 8 site and will cover:

what's currently available in Layout Builder
what's coming next in core, look at what we really want to see next
Oct 4 update: now introducing Layout Builder Kit, a set of components you can use on your site and a framework for your own components!
the existing modules that provide functionality not yet in Layout Builder
the key decisions you need to make when creating your own Layout Builder components
some gotchas when working with Layout builder, particularly with multilingual sites
how to use Layout Builder effectively depending on the type of page you are creating
When you leave this information-packed presentation, you'll be right up to date with Layout Builder and ready to make decisions on how to use it on both large and small sites.

• André Angelantoni, Founder of Performant Labs, a Drupal consulting firm based in San Francisco
Neerav Mehta

You a Drupal site builder who either doesn't know PHP or doesn't like PHP coding. But you want to configure your site to execute certain actions based on some events and triggers. Example use cases are:

Set up marketing automation rules for sending personalized emails to users depending on the actions they take.
Redirect users to different dashboard / page depending on the roles they have.
Validate values of a form submission without using any code.
This session will teach you how to do exactly this using the If Then Else ( visual programming module. It lets you automate execution of actions on your site by connecting code blocks using a drag-n-drop editor and not touching PHP code.

Program your site without using any code!

For those of you who are familiar with Rules module, here are the major differences:

Modern graphical UI using rete.js library ( Flows are much easier to set up and inspect.
Support for "Else" statement is in-built instead of relying on a separate module.
Support for form alteration, validation and submission is in-built without relying on a separate module.
Much easier to track inputs to conditions and actions for an admin who is not familiar with Drupal's tokens.
The session will include a demo of how you can use the module to set up different flows on your site. If the audience desires, we'll also go into the underlying PHP code and how you can contribute to enhance the module even further.

You'll benefit from this presentation if:

You are a site-builder who wants to automate actions on your Drupal site without touching PHP.
You are a module developer and are interested in contributing back to Drupal by working on enhancing the If Then Else module.
You are a UI/UX designer / themer and have suggestions on how the UI/UX can be improved.
Keegan Rankin

As a recent bootcamp graduate, I will discuss the multiple stigmas surrounding bootcamps (and their awkward socioeconomic role), their various implications, and finally my experience learning Drupal independently after completing my program. This analysis will support my ever evolving answer to the question, "What am I learning and why?"

update: Since writing this proposal, the ideas I have prepared have continued to form into something more. I will be sharing what I have learned about the economy from attending a bootcamp, and about the changes we can make as developers to uncover the meaning of the things around us.
Anthony Horn

SVGs, or scalable vector graphics, are great for logos and simple images as their resolution is always as good as the monitor you are viewing them on, but there is so much more. In this session we will look at all the ways to add svg to a web page based on intended use, methods for animation, browser support, helpful libraries, and accessibility. In addition we will explore some creative ways that SVGs are used to create interactive images, interfaces, filters, and masks.

What is an SVG

Free SVG Editors

Animate SVGs

Adding SVGs to a Web Page

SVG Libraries



Security Concerns

Avatar Drupal Demo Module

Cool Stuff
Andrew Mallis

I was a self-taught Google Analytics user. I thought I was getting by OK.

But, since working with professional analysts, I’ve seen how my data wasn’t as complete or accurate as I thought I was. And with bad data, it’s easy to tell the wrong story.

I’m here to level you up, and share best practices for setting up your Google Analytics accounts.

In this talk, we will:

provide recommendations on best practices for setting up your views, filters, and goals

explain the connection between users, sessions and pageviews

look at the power of Search Console for unlocking SEO insights

outline strategies for UTM link generation and recording

demystify (and devalue) bounce rates

show how to improve the accuracy of your referral traffic

point to how GTM can be used to unleash features like video tracking, heatmapping, and more

Demonstrate how you can debug GA tracking in real-time

and more!

Attendees will walk away with a handy and concise 3-page guide to take them from basecamp to summit.
Jesus Manuel Olivas

Drupal 8 supports a "Headless" mode out-of-the-box. A headless CMS allows content creators to manage their content through a familiar admin interface and providing the content via API endpoints, allowing developers to implement a fully customized front-end experience using reusable components and a modern framework as React.

A core feature of Gatsby is its ability to load data from anywhere (Drupal JSON:API endpoint in our example). This is what makes Gatsby more powerful than any other static site generators that are limited to only loading content from Markdown files.

Gatsby is taking the world by storm and the JAMStack is here to stay. Come to this session to learn how to embrace the modern web using Drupal as a headless CMS with Gatsby.

During this session you will learn:

- Which modules you need on your Drupal site to behave as a headless CMS and provide better integration with Gatsby.
- How to install Gatsby.
- Which Gatsby plugins are required for better integration with a Drupal data source.
- How to properly configure Gatsby plugins to take advantage of Markdown preprocessing.
- How to configure Drupal and Gatsby to provide an instant preview on content changes.
- How to use the GraphQL endpoint provided by Gatsby to query data from Drupal JSON:API.
- How to create pages (home, taxonomy, full node) on Gatsby.
- How to trigger automatic builds based on content updates.
- How to deploy your site to a CDN.
Jen Lampton
Nate Lampton

Backdrop CMS is now nearly 5 years old. Since its first release on Jan 15th, 2015, what has changed?

Is Backdrop substantially easier to use than the Drupal it was forked from? Is it more affordable to support? Are the APIs you know and love, still stable and functioning as they were? Is the community growing and healthy?

If you haven't been following along with all the improvements to the software or the growth of the community, this session will give you a good overview of where things are today. We'll cover all the major new features that were added in each on-time release, as well as point out when infrastructure and community tools were put into place.

A fork is the point where something divides, with each part moving in a different direction. Come see our new direction!
Chaz Chumley

Each iteration of Drupal introduces new and exciting ways to manage content. However, the display of content is even more important along with the knowledge of how to convert a design to a theme. While we have all read about, watched and even worked with Twig to create new themes in Drupal 8, the way we work with Twig has changed.

Join us as we discuss how traditional theme-centric design has quickly moved into component-based design. Together we will master Component-based theming with Pattern Lab as we work to identify patterns and define components, how to quickly create a Pattern Lab managed Drupal 8 theme and Learn how to work smarter in developing components that can easily be integrated into project after project without having to recreate yourself.

If you consider yourself a front-end developer then you will be right at home learning all the newest techniques to take your skills to the next level as we master Component-based design with Pattern Lab.
Ray Saltini

Ever feel like you're jumping from one problem to the next putting out fires but never get the bandwidth to implement longer term solutions? This 45-minute session focuses on the importance of establishing baseline assessments and measuring progress through regular formal audits of your content, architecture, workflow and infrastructure to seize opportunities that will strengthen visitor journeys and increase conversions. This session is geared to both new and experienced web professionals struggling to find ways to get beyond their daily grind and make lasting improvements in systems and decision making that benefit site managers and end users alike.

Among the topics this session will cover are:

Principles of website auditing and getting stakeholders to buy in.
How to start cataloging content to identify gaps and opportunities.
How to begin improving usability and create a system to ensure continuous accessibility compliance.
What to expect from a security audit and how it can improve customer experience.
The most important elements of site performance that effect customer experience.
Yas Naoi

We are developing our Drupal 8 distribution, Cloud Orchestrator by practicing Scrum for Agile software development. I'll introduce the background story of the reason why we could successfully achieve our super-fast paced development with higher productivity.

The Agenda:

Scrum Agile Development
Scrum principles
Our Team
We are a small team
Challenging Time and Space
Our team members are totally distributed geographically
Development Cycle
The iteration
Development Process
Issue tracking, Chat, VCS and the Tests
Project Management
Requirements and backlogs
Sprint planning and review
Story points
Software release management
Mark Burdett

The California Consumer Privacy Act (CCPA), a new law intended to enhance privacy rights and consumer protection for residents of California, goes into effect on January 1, 2020.

We'll talk about what sites may need to do to be compliant with CCPA, including privacy-enhancing Drupal modules, and some best practices for website privacy, as recommended by the Electronic Frontier Foundation (EFF).

Note, the presenter is not a lawyer and this talk is not legal advice - talk to your attorney for specific legal advice re: CCPA and other regulations that may apply to you :)
Charles Jackson

FUJIFILM SonoSite is the leading global provider of portable ultrasound equipment. Local regulatory restrictions prohibit SonoSite from publishing product-related information in a country before a product has been approved for sale in that country. Because products typically are cleared in Europe before the US, the translated versions of product pages need to be published, while keeping the US-English source pages unpublished. The SonoSite web site also uses a large number of views that must also follow these restrictions.

The problem we faced is intrinsic to the Drupal entity translation model -- when you unpublish the source, all of the child translations are also unpublished. Views that leverage this content also break -- badly.

The solution we devised was to to create a hidden copy of the English-language source (using a different language code), publish all content, and make US-English a "translation" of the source. As a translation, US-English pages could easily be published and unpublished, and views that leveraged that content would behave appropriately. Only logged-in administrators would see the "hidden copy" (which we called The Ghost); website visitors would never know it existed.

Turning our existing Drupal 7 site into a Ghost-enabled site presented us with a series of interesting challenges, leading us to bend (and sometimes break) Drupal in many new and different ways.

During the case study, we'll explore most of these, which include:

Choosing a language for the Ghost -- Why Antarctica?
The source language is no longer the default language -- how we convinced Drupal to make it so.
How we programmatically cloned the English-US content into the Ghost
How to create and publish new content (you need to start with the Ghost and "translate" to other languages -- including US-English)
Getting the Ghost to play well with Lingotek
The Ghost Language project took nearly two years, and enlisted the advice and assistance of a number of players, including Lingotek, Hook42, Smartling, OneClick, and many others.
Jim Vomero

Drupal includes a powerful toolset for building and extending out-of-the box content types. Content architectures are typically designed around the features of nodes, taxonomy, media, and other core entities. But how do we know when our business-needs have grown beyond the common entity types? When are nodes too lightweight or too heavy handed to meet our site goals? And what are the trade-offs and support issues when creating a new entity type?

This session will look at the landscape of core content entities and discuss the relative strengths and limitations of each entity type. We will explore common business-cases for developing custom entities and examine the level of technical debt incurred with various types of solutions. The session will consider real-world use-cases, including:

Reducing overhead: When content types (nodes) are too big.
Optimizing: When content types (nodes) are too small.
Presenting highly-customized editorial experiences.
Defining unique access control handlers and permissions
Using non-standard storage for modeled data.
Reusing content definitions through bundles.
When performance tuning is an overarching goal.
This presentation is designed for attendees in technical leadership roles. Programming knowledge is not required, however example code and links to developer resources will be shared to highlight features of the Drupal Entity API, Drupal Console, and the ECK module.

Participants should leave this session with an understanding of the risks and liabilities of creating custom content types; but also feel empowered and excited to employ them when they’re the right tool for the job.
Jen Dary

A promotion to management. A Drupal project royally derailed. Bringing home your first child or a medical diagnosis or getting laid off. There are specific times in our lives when we get the strong instinct to look over our shoulders and ask, “who is coming to HANDLE this?!”

Surprise! The answer is you.

No matter our career path, part of maturing into leadership and more senior positions is growing the ability to navigate turmoil responsibly. While it sure would be nice for someone to come save us, we live in the real world. Time (and life!) reveal that WE are the ones we have been waiting for.

In this session, we will talk about concrete examples of these moments at work. Jen will reinforce strategies to get attendees through difficult career moments via self awareness and resourcefulness. We will take a pledge together and leave the room more empowered employees than when we first arrived.
Michael Schmid

Decoupled Drupal is clearly here to stay, so what does this mean from a business point of view? As we consider all the implications of this change — a new programming language, new license, and the technical considerations of how we visualize and build websites — it’s important to identify how and when adaptations need to be made to our businesses to support all these changes.

Amazee has been working on decoupled Drupal projects for over three years. In this session we will share lessons learned as a business so far and what we envision in the future. Attendees will walk away with insights into how decoupled projects can affect:

Hiring, staffing, and team sizes

Contracts and client relationships

Budgets and profits

Project management, processes, and maintenance

New possibilities in decoupled projects

Although change can be hard, we believe the future of decoupled Drupal is bright. Let us show you why.
Benjamin Melançon
Clayton Dewey

A handful of visionary people in the city of Cambridge, Massachusetts wanted an online resource to help families easily find activities, services, and resources.

Find It Cambridge was informed and further inspired by extensive initial research done by Code for Boston and the City of Cambridge. As this was wrapping up, the city brought Agaric in, so we found ourselves in the incredibly fortunate situation of starting with this in-depth knowledge.

This session will start with highlights from this research conducted before anything was built. Next, we will take you through the iterations of design and mockup testing led by Todd Linkner, our design partner. We'll also cover the learning from the initial user testing with people in a library computer lab, which was particularly real-world conditions for this site! Finally, we will go into the iterative improvements continuing through today, regularly informed by feedback from people using the site in real conditions.

We will also discuss the challenge of balancing client feedback with user feedback and offer strategies for making sure user needs are prioritized, including how to be a user advocate no matter what your role in a project is. We will take you through some of the client-developer decision processes and present what we've learned and how we plan to continue building on what we've learned as we continue to build on this amazing citizen resource.

The philosophy throughout has been listen, watch, learn, and then use the knowledge gained to develop and prioritize enhancements and new features. The most interesting parts, as so often, lie in the details. This session will also present frankly what could have been done better, and what could still be done better.
Victoria Miranda
Brian Manning

As a Project Manager, Strategist, Developer, Designer, or Stakeholder, we are all part of the puzzle—and it's crucial to keep sight of the big picture—even when we’re required to pivot from the original plan. Pivots come in a variety of shapes and sizes. They can be a minor change that’s quickly integrated into the scope or a major departure that alters the entire course of the project. When you encounter these shifts, it’s vital you strategize, communicate, and continue to capture the vision of the client so the final product is a solid foundation for your client’s goals and KPIs—not a point of resentment.

Each pivot adds a new element that you have to take into account. If you keep some key points in mind, you will be able to deliver your project on time, within budget, and create a lasting relationship with your client.

In this session, we’ll review the following concepts for managing projects in danger of derailment:

Kicking off the project with an organized team and plan of attack

Capturing the client's vision

Asking the right questions early

Communicating with your whole team





Stakeholders (yes, they are part of your team, too!)

Avoiding the dreaded “overcommitment”

Identifying the Goal and Plan on how to accomplish it

Being ready to PIVOT

Keeping your team grounded in the delivery

Managing team morale and motivation

Avoiding burnout and frustration

Don’t get caught up in too many meetings

Continue CLEARLY communicating with your stakeholders

Getting ready to deliver with success!

Conducting a retrospective and additional planning—not a postmortem
Danny Teng
Neha Bhomia

Tired of having to caption all the images on your website? Manually inputting alt tags for images gets tedious, and missing some decreases your site's search weight.

Look no further than machine learning. A powerful tool in the field of artificial intelligence, machine learning can be leveraged to solve this tedious task.

Ease the burden on administrators and developers
Optimize your website for search engines
Saves work-hours needed in manually describing images
Attendees will learn about the basics of the machine learning, examples of successful use cases, as well as a live demo of image captioning being used.
Jason Mickela
Meg Claypool

Integrating with a third party product or service can be one of the fastest (and cheapest) ways of bringing advanced functionality to your site. Companies like Salsa Labs, Salesforce, and Stripe have put lots of work into services that can help you bring a great campaign, donation, or sales platform to market quickly, and without having to build out that functionality yourself.

In this session we'll go over various integrations available, how well they work with Drupal, and where you can get the most bang for your buck with them. We'll also go over some pitfalls to avoid when integrating with a third party service. For example, many integrations will come with API limits or charge on a per-use basis and an unexpected traffic spike can end up costing you thousands of dollars. This isn't a very technical session and, for the most part, is a high level overview which will help you ask the right questions about which integrations to use for your site and which ones you should either avoid or develop in-house.
Sarah LeNguyen

Web developers with skills in Drupal, WordPress and modern JavaScript have long been in high demand, leading to tough competition for top talent. For hiring managers at all types of organizations, the prospect of recruiting a new team member can seem daunting at best and downright frustrating at worst. The recruiting process can also be very challenging for developers. How can they best assess culture and fit of an organization through just a job description and a few interviews? What should they keep in mind when searching for a new position to keep up their career progression? The recruiting process -- while relatively brief -- is a chance for both employer and candidate to make strong first impressions, which will pave the way for a (hopefully!) long, mutually beneficial relationship.

In this session, we will cover how hiring managers can determine their “ideal” employee and target recruiting efforts to find him or her. That process includes everything from a well-written position description to initial skills assessments from applicants to an interview process that allows both sides to determine a potential fit. We will also cover negotiating the offer process so that both sides are happy with the outcome.

This session will also appeal to developers who are actively looking for a new role or who plan to start a search soon. They will get an insider’s look at the recruiting process from an experienced hiring manager’s point of view. They also get tips for navigating the skills assessment and interview process, and how to tailor their job search to the positions where they can grow professionally.

Making a great hire is just the first step to building a strong development team. The harder part is retaining talent. In the second part of the session, we’ll cover how managers can keep their team members motivated, challenged and performing their best. We’ll also encourage an open discussion amongst attendees about their own experiences on both sides of the equation, and what developers are looking for from employers -- in the interview process and once they’re onboarded -- to keep their job satisfaction high.

Topics to be covered:
What the recruiting process looks like from one employer’s point of view.

Identifying your “ideal” employee and writing a job ad that gets their attention.

Defining appropriate and fair skills assessments.

Conducting interviews so that both parties can assess fit.

Retaining talent by removing de-motivators in the workplace.

Who should attend:
Hiring managers of technical talent at their organizations.

Developers who are looking for a new position or who might start a search soon.

Those who participate in the recruiting process at their organizations.

Those who are curious what the job market looks like currently in open-source web application development.

Attendees will leave with:
Shared experiences from a hiring manager who has been recruiting Drupal talent for more than 10 years.

Hints and tips on how to implement a recruiting process that benefits both recruiter and candidate.

Best practices for both parties in the recruiting process.

This session made possible by Forum One.
Anne Stefanyk

Virtual. Remote. Distributed. Pick your label. This style of organization is becoming more popular and in-demand among many Drupal shops. While many folks have gone remote, some people find the experience quite isolating and disconnected.

Does remote work make people happier? Does it make them more productive? The answer is not really. It is not the act of working from home that creates employee happiness; it is creating a culture that fosters remote practices to develop meaning, collaboration, and happiness.

Building and sustaining strong relationships with colleagues and clients require both a unique approach and the use of a variety of tools to create the right work culture. The success of a remote team also depends on management, how the team is supported, and the systems in place.

In this session, we will talk about how to be the best remote employee. The session will also provide strategies and ideas if you are a leader of a remote team. We will talk about key tactics to keep you (and all other staff) inspired, creative, productive and most importantly, happy!
Abhijeet Sinha
Vidhatanand V

According to IDC, 90% of all the digital information is unstructured locked in multiple repositories and digital businesses have either underinvested in technology or invested in substandard technology in order to access them. Traditional search method leads to failures majorly due to the absence of optimisation practices and lack of unified framework. In a data-driven world, unlocking the hidden insights, that are shut off from view within both structured and unstructured data present in multiple repositories, is more critical than ever.

Today, the sheer quantity and the pace of digital information that knowledge workers have to deal with every day are dramatically increasing. To tame the chaos of multiple repositories is a challenge. There has to be a deployment of a search method over distributed and even heterogeneous data sets in order to receive a unified results list. This brings us to Federated Search.

OpenSense Labs initiated one such enterprise search tinkering robust Apache Solr and versatile Drupal 8 for eleven different websites with a great variation in CMS leveraging portability using Node JS.

In this session, we will equip you with the know-how of:

Enhancing website search experience retaining a blend of useful and accurate results
Expanding inter-site searchability decreasing the bounce rate and latency
Increasing data discovery and interoperability of information by cross-functional support to a plethora of platforms

The major takeaways would be:

Challenges amidst architecting a microservice
Scraping content using an open-source tool like Scrappy
PHP is slow, how do you make Drupal faster?
Fiddling the Solr configuration and boosting queries
Using Node JS to serve content on the go
Aaron Feledy

Asking members of your team to spin up local copies of your Drupal application can result in an assorted array of solutions to the same problem: Some may spin up virtual machines while others may cobble together their favorite combination of Docker Containers. Some may struggle with native solutions on their machines while others may be entirely uncertain on where to begin. Adding common services and development tools such as xdebug, mailhog, or Drush may pose additional problems to even the more savvy members of your team.

Whether you need to simulate infrastructure(e.g. redis, nginx, solr), helper services(e.g. mailhog, phpmyadmin, xdebug), development tools(e.g. grunt, drush, composer), or common automation tasks(CI, testing, building deployment artifacts), Lando provides a solution to quickly specify and painlessly spin up the services and tools needed to develop your projects. It's a free, open source, cross-platform, local development environment and DevOps tool built on Docker container technology. Designed to work with most major languages, frameworks and services, Lando provides an easy way for developers of all types to specify simple or complex requirements for their projects, and then quickly get to work on them.

In this presentation, you will learn some Lando basics, including how to use Lando's built-in recipes to quickly spin up Drupal environments. You will learn how to define your development stack in a simple Lando configuration file that can be committed to your code repository and shared with other team members. You will learn how Lando can easily push and pull code, database, and files from hosting services such as Pantheon. You will learn how Lando can perform automation tasks and how easily it can do testing and CI. You will also learn how Lando can be used to build a decoupled Drupal/Gatsby development stack in just minutes. Most importantly, you will leave this session knowing that after making the switch to Lando, your team will never need to configure a virtual machine or install another local development tool for any of your projects.
Michael Lander

Drupal has always been very strong at customizing user experiences for authenticated users, but what about anonymous users? What if you wanted to show a new banner block on your home page for first time visitors? Or gate a resource until users have filled out a contact form? For the most part, anonymous user display is determined by the url path, and per-user customization is dependent on excluding the page from cache, custom javascript or third parties. In this session, we'll introduce the Smart Content contributed suite of modules. Smart Content at its core is a toolset for defining conditions based on data attainable from anonymous and authenticated users(such as cookies, browser properties and third-party data), and providing subsequent reactions utilizing Drupal's content editing prowess. In this session, we'll cover initial setup and some basic use cases for the modules, as well as dig deeper into what's under the hood and how it all works.

Key areas we'll address:

Brief overview of personalization, the modules and project history
Module setup and step-by-step implementation walkthrough
How it works and how we minimize impact on performance
Potential use cases and sub-module ecosystem
How you can get involved!

A basic understanding of site building in Drupal will help you get the most out of this session. Technical details will be explained mostly at a conceptual level. We'd like for you to walk away as energized about the project as we are, with enough know-how to start trying the modules on your own projects. Smart Content gives you a great way to introduce yourself into the world of personalization without ever leaving Drupal.
Lily Berman

When Lily first started working near Drupal (account and project management in a Drupal agency), she came from working near French (marketing and fundraising for a French cultural center). She immediately approached Drupal as a new language, and used this perspective to learn and then to teach. She saw how clients and non-technical colleagues can easily be left out of the conversation by pervasive jargon… fields, views, and modules, oh my! Most of the time, the team does not realize they are doing this, nor how to quickly and easily bring everyone into the discussion.

Independent of your role, if you talk to clients or people new to working in Drupal, you will benefit from this session. You will leave the room empowered to both recognize and efficiently translate any specialized terminology into language that can be understood by any audience.

In this session, you will learn how:

Valuable it is to build mutual understanding early and often
A hosting provider is just like a desk, a release is just like a cup, and analogies aren’t just for university entrance exams
To build useful analogies to efficiently help people understand jargon
Aimee Hannaford
Ryan Bateman

View Modes are the site-building glue that brings your content strategy, design, media strategy, and UX development together to actually create your web displays.

View Modes have been in Drupal for some time, but what do they really do? Why are they so powerful? With Drupal 8, View Modes are now even more relevant with the standardization of Entity and Field management across entity types.

With Layout Builder in Core, it is important that you create a harmonious View Mode and Layout Builder strategy. Think beyond the Teaser and Paragraphs for display flexibility and harness the power of View Modes!

View Modes in core:

Anatomy of a view mode.

Common applications of view modes across entity types.

View modes and media (media entities and file displays!).

What the “Default” view mode does vs. Full Content.

Architecting View Modes for your site:

Planning your View Mode + Content + UX + Component Library strategy.

Interacting with layout solutions. (Panels / Display Suite / Views)

Extending view modes in code.

Lessons Learned with View Modes:

Interactions of view modes across entity types.

Naming is important. What does “Teaser” really mean?!

But why can’t I use that view mode?!

View Modes and Layout Builder

Configuration of both display systems.

Considerations with approach.

Future development path.

This session listed as “Beginner”, but the concepts and information can be applied to more advanced architectures.

Coming as a Site-Builder? You should know how to create content types and have reordered fields on “Manage Display” at least once.

Are you a project manager or designer? Be familiar with basic Drupal terminology like a node, content type, and field.

Are you a Drupal Developer? You know enough to join this session. :)

Share with the community that there can be more than just Full Content and Teaser.

Provide tools for Site Builders to create powerful displays with little or no coding.

Explain why View Modes are a powerful tool in your Drupal tool chest.

Terminology and concepts to connect design, content, and technical execution.

View Modes applied to different entities may mean different things.

Practical knowledge to apply for their own site extension.

Layers of View Modes can and will interact with each other. Layering must be deliberate.

By Role:

Project Managers: Understand that View Mode creation and extension requires effort which you need to include in planning.

Content Strategy / Analysts: How do view modes interact with content and functionality through the site.

Designers: The language and concepts to communicate your design vision to the development team.

Site Builders: Build what they are asked by the design and project management team. :)

Drupal Developers: Understand why all these non-coders on your team have created View Modes when you are asked to help possibly extend their displays. :D
Dwayne McDaniel

Don't you wish there was a way you could give each and every user of your module's admin experience a quick and easy way to learn what each setting really did and why it was there? Good news Drupal 8 users, this is actually in core. The Tour Module has been in core since the first release of Drupal 8 and is awaiting you to leverage it.

In this session we will explore how to first a tour and then implement it for your site, letting you better communicate with your users. Leveraging easy to read and write YML and with the power of Drush, it is very fast to iterate and test changes on our sites. The tools for making Drupal more user friendly has never been in a better state, so let's learn how to use this feature to make it even more appealing, especially to new users!

This session is intended for intermediate to advanced developers and site builders alike, no matter if you are building your own modules or just using Core.

Walk away having learned:

* How to find and enable existing Tours
* How to structure your Tour files for better collaboration
* Best practices for writing Tour content
* Basics of Drupal 8 routing system and Configuration Management best practices
Jim Vomero

Drupal’s extensibility allow us to create the perfect CMS for our organizations. But too often the same level of design is not considered when building out the editorial interfaces. The default tools are often scary for first-time Drupalers and include confusing words like ‘nodes’, ‘taxonomy’, and ‘blocks’. Making Drupal friendly for clients means checking internal jargon at the door and building interfaces that are intuitive and distraction free. Topics include:

Creating personalized dashboards for authors and editors;
Modifying the entity add and edit forms;
Adding contextual help to administrative interfaces;
Using constraints to provide meaningful form validation; and
Choosing field, widget, and storage types that are best fit our content.
This sessions is for attendees in site-building and technical leadership roles. Participants should leave this session with ideas for: taming their content forms, building out useful content dashboards, and enhancing their editorial workflows.

Programming knowledge is not required, however example code and links to developer resources will be shared to highlight features of Drupals Core APIs; Views, Field UI, and Contributed modules; and custom code for taking control of your theme and admin interfaces.
Mark Casias

There is a lot of talk about how great a decoupled site is, and more to the point, how great it is to use GatsbyJS. So much that Mediacurrent has converted their main website to a GatsbyJS based decoupled site. Then there is a lot of problems that come with a vanilla Drupal installation, or using other install profiles. Mediacurrent has created the Rain install profile, and with it a Gatsby based starter.

This talk will review

The pros and cons of decoupling with GatsbyJS
Show the ease of use, using the Rain install profile along with the Rain Gatsby Starter.
Discuss some of the pain points discovered in the making of the starter and converting to a decoupled GatsbyJS including
JSONAPI endpoint problems
Working with Paragraphs or other layout systems.
Missing data issues
Metatags and other core concepts that need to be addressed.
Working with image entities in GatsbyJS
Third Party JS issues (Disqus, Pardot, Drift etc)

Drupal is a registered trademark of Dries Buytaert.