Navigating Local Development Landscapes: Tools, Benefits and Best Practices

[00:00:02] Michael Meyers: It works on my machine. That was the catchphrase to life before local development tooling became a thing. I can still feel the pain, right? It took way too long to get new developers onboarded. It took many senior people to do it. There were countless hours that were just wasted chasing down bugs that were just conflict and environment conflict issues.

[00:00:29] Michael Meyers: And the really frustrating part is that tools like DDEV have been around for almost a decade now, and you'd be surprised how many people aren't using local development tooling still, or at least aren't using them to the extent that they should. And it got me thinking, what, why? What is going on? What are they missing? And maybe, what am I missing?

[00:00:47] Michael Meyers: Hello and welcome to Tag1 Team Talks, the podcast by Tag1 Consulting. I'm Michael Meyers, the managing director at Tag1, and today I'm joined by Mauricio Dinarte, a software architect and data migration expert and the author of Tag1's Comprehensive Hands-on Guide to Data Migrations.

[00:01:04] Michael Meyers: Together, we're gonna dig into local development environments, why they matter, how they help developers and teams, the tools that make it easier, a brief overview of DDEV, the features that we love and use all the time, why people aren't using them, and the rise of cloud-based editors and what that might mean for the future of development in local development environments.

[00:01:32] Michael Meyers: But first, a quick plug because this podcast wouldn't exist without Tag1. Tag1 is the number two all time contributor to Drupal, the world's second most popular CMS, and for almost 20 years now we've led the development of many of the features and best practices that millions of websites and several hundred thousand organizations depend on every day.

[00:01:50] Michael Meyers: And while Drupal's at our core, we're a full service technology partner from discovery and design to building and scaling complex applications, managing infrastructure and performance tuning across a wide range of technologies and platforms. Organizations, including Google, the New York Times, and the City of London, trust us to solve their mission critical problems.

[00:02:06] Michael Meyers: To learn more, reach out to [email protected]. That's TAG the number one dot com. Mauricio, welcome back to the show. It's great to have you.

[00:02:13] Mauricio Dinarte: Thanks for having me.

[00:02:19] Michael Meyers: I feel like every time I talk to you, you are somewhere else in the world, running around talking at events and conferences. Where are you today?

[00:02:26] Mauricio Dinarte: By the time this podcast comes out, it will be very close to DrupalCon Vienna, and I am slowly making my way there, coming in from place to place.

[00:02:39] Michael Meyers: Awesome. I love it. So, quick confession before we get started. When was the last time you caught yourself saying “it works on my machine”?

[00:02:50] Mauricio Dinarte: Uh, yesterday. Yes. It was for a very pesky migration issue, which in the end didn't have anything to do with migrations, but after a good debugging session we were able to pinpoint the issue and actually DDEV was instrumental in providing the tools to be able to resolve the problem.

[00:03:16] Michael Meyers: So, for those who aren't familiar, at a high level, what exactly is a local development environment?

[00:03:24] Mauricio Dinarte: For the most part, we want to replicate the same environment that our production site is running on, on our local machines. That means same version of PHP, which is what Drupal runs on and depends on, database servers, web servers, and so on. But just as I alluded before, sometimes things do not go as expected and you may need extra tools, and DDEV provides debugging, profiling, and database and email tools for inspecting them, and that is part of what we will be discussing today.

[00:04:04] Michael Meyers: There are a lot of different reasons that you would use a local development environment. From a developer perspective, as an individual there are a lot of benefits. Let's say you're typically working on multiple projects at the same time: personal stuff, different client projects, Drupal contributions. There's different versions of PHP or databases potentially in the same project. That's a pain in the ass to deal with and manage. How do local environments help with that?

[00:04:34] Mauricio Dinarte: For one, you can easily change from one version to another for each of these dependencies that I mentioned before. In my daily work, I spend a lot of time doing migrations, for example, from Drupal 7 to Drupal 11, and the version of PHP is one of the things that changes between the two, like the minimum requirements.

[00:04:55] Mauricio Dinarte: Sometimes the version of the database servers is also different. So even while working on the same project for the same client, I need to have two different sites with two different configurations. And a local development environment allows me to meet those requirements without having to spend too much time thinking about it. It is literally a configuration file. I specify the PHP version that I need, the database version that I need, run DDEV start, and I'm ready to go.

[00:05:25] Michael Meyers: When you're working as part of a project and doing development locally before you contribute to a hosted environment, a shared environment with the team, it's critical that you debug your software, right? You don't want to derail the team, yet getting up and running with a lot of the debugging tools and software again can be really challenging. How does a local development environment tool make that easier?

[00:05:53] Mauricio Dinarte: For local development environments, it really depends on the tool that you're using. In the case of DDEV, it has fantastic integration with Xdebug and XHProf, which are debugging and profiling tools respectively, and it even goes beyond that.

[00:06:08] Mauricio Dinarte: Recently they added what is called XHGui, which is a web interface for profiling visuals, and there is a plugin that is called SPX that is yet another level of visually seeing the performance of your application.

[00:06:24] Mauricio Dinarte: Just taking a step back, having the tools is one thing and using the tools is something different. The benefit of having a local development environment is that I am one click and one command away from being able to use them. For example, if you're using PHPStorm, there is something called zero configuration for debugging. You literally click a button in the IDE and you issue one command for DDEV to start the Xdebug session and set a breakpoint, and you are ready to go.

[00:06:57] Mauricio Dinarte: So the time between finding a problem and being able to start debugging the problem is pretty much zero seconds, to be honest.

[00:07:09] Michael Meyers: I remember development back when I did a lot of development, before there were local environments. Getting up and running with XHProf required expertise. It wasn't easy to do that on your local machine. It's awesome that these tools support these features and functionality. Does it just work out of the box? How easy is it to add it? Put this into context: we're talking about really robust functionality. Is it still hard to make it happen?

[00:07:38] Mauricio Dinarte: It could if you are not using tools like this, and it also depends on your expertise. Just as an anecdote, when I started with web development more than 15 years ago, I would literally spend a couple of days just trying to set up the requirements to run a Drupal website.

[00:08:02] Mauricio Dinarte: Today, tools like DDEV give you a quick start guide you paste somewhere: seven commands, and five minutes later you have a fully working development environment, not only with PHP, database, and web server, but with all these extra tools that we are discussing today.

[00:08:12] Michael Meyers: Wow. Yeah, we had Randy Fay, one of the project leads for DDEV, on a couple of months back, and literally minutes to get up and running. And I haven't done a lot of development in a very long time. Even a non-technical person could spin up a DDEV environment by following a checklist in five minutes and have a local environment running to work with and play with Drupal CMS or something. It was crazy easy.

[00:08:47] Michael Meyers: Testing—you know, we talked about debugging and things like XHProf. Testing is critical to catching issues early in the process. What kind of tools are there for this, and how is it helping on that front?

[00:09:04] Mauricio Dinarte: To get started, you have database GUIs to be able to connect to the database, either a web interface or your personal client of choice. By doing that, especially with a migration, you can see the source data at the database level, and if something is not coming along as expected, you can detect it from there.

[00:09:26] Mauricio Dinarte: Another area that is common is email. So DDEV comes with a tool called Mailpit, which basically captures all email by default. Depending on how you set up your site, you might need to take some extra configuration steps, but in a common configuration, it is enabled and configured out of the box.

[00:09:53] Mauricio Dinarte: So we have database and email, but then depending on your circumstances, you can do PHPUnit testing or coding standard checks. You can do static analysis. There are plugins, for example, to integrate with BrowserSync or other frameworks that allow you to test your frontend or test your API.

[00:10:15] Mauricio Dinarte: Just to plug another Tag1 product, we have a product called Gander, which is for performance, and there is a DDEV plugin which we created that will install the tool to be able to do performance checks automatically.

[00:10:29] Michael Meyers: These are the kinds of things that you need infrastructure teams and DevOps teams for. When we set this up for development, staging, and production in a hosted fashion, this requires a tremendous amount of expertise and configuration, and a local development tool is providing this out of the box in minutes for your local usage.

[00:11:00] Michael Meyers: But there are many benefits to these local development environments, and a big one is addressing consistency of environments so that you're developing in an environment that's very much like a production environment. In modern web applications the production environment is crazy complex. You have caching layers, you have search engines, you talked about mail. Can it really replicate what's going on in production and have all of those services, or are we still working in a microcosm, an approximation of the environment?

[00:11:41] Mauricio Dinarte: In many cases you can literally replicate the configuration as production. If we talk about caching, you know, Memcache, Redis, Varnish— all of those services are available, for example within DDEV. For search, if you are using Apache Solr or Elasticsearch, that is also available.

[00:12:02] Mauricio Dinarte: For other services like S3, you might not have S3 directly in your local environment, but there are add-ons that will give you an equivalent API so that you can use them. There is one called MinIO. There is a DDEV plugin for that, and that is going to give you an S3-equivalent API so that you point your local environment to that and you can expect that it is going to behave as the real thing.

[00:12:26] Michael Meyers: That's amazing. It's really, really powerful that you can do that.

[00:12:32] Michael Meyers: So it's not just developers that benefit from this, and it is not just about trying to replicate production environments. There's a lot of other things going on here. From an organizational perspective, from a team perspective, there's a lot of things that it helps with. In particular, one of the challenges that we've all talked about is getting a new developer set up and running. Historically that took a tremendous amount of expertise. Senior people needed to onboard the person. It was time consuming. How does this tooling make that process faster and easier?

[00:13:14] Mauricio Dinarte: One way is that it is usually do it once, configure it properly once, and then just reuse. Normally a senior developer can set up everything that is going to be needed, provide instructions in a README file, and then anybody on the team can follow them.

[00:13:21] Mauricio Dinarte: And I want to highlight that this is not only for technical people, because again, we are focusing on DDEV, but similar tools work the same way. You can follow a set of instructions and as long as you have Docker and DDEV installed, you are going to have a copy of the site running locally in which you can do your local manual testing, for example, if that is what you are up to.

[00:13:57] Michael Meyers: It really democratizes the technology. You can work in marketing and if you want to practice or work on content creation or something as part of a migration process, there's really no end to how you can use these tools.

[00:14:11] Michael Meyers: One of the cool things that we do with infra ops for a lot of our clients is we sync back production changes. So if we're making caching layer changes or adding infrastructure or just tweaking a config file, it's critical that that gets propagated back out to everybody on the team and their local development environments so things stay in sync.

[00:14:31] Michael Meyers: So there's this whole sort of infra ops toolchain cycle that ensures that you not only can get up and running with this tooling, but that it continues to stay in sync so you don't reintroduce some of the fundamental problems that it's trying to solve.

[00:14:53] Michael Meyers: Some of our clients dictate “you have to use this laptop, we're issuing you a physical laptop,” or dictate that you need to use certain technology and tools for various different reasons. But most of the time we let our developers use whatever tools and technologies they love most. We have people on Macs, we have people on Windows PCs, we have people running Linux, all sorts of different tooling. So it is a pretty complex and diverse setup. How does the local dev tooling work across all of this, and provide any benefit in doing that?

[00:15:29] Mauricio Dinarte: I think for this we need to take a step back from DDEV and notice that DDEV works on top of Docker, and Docker is multi-platform by itself. So this is the layer that allows us to go from one operating system to another with very little friction.

[00:15:57] Mauricio Dinarte: In terms of what specific local development setup we use, in the case of DDEV, you have one setup because it is running on these Docker services, which are compatible with many different platforms. They're just going to work.

[00:16:07] Mauricio Dinarte: One thing that I want to point out is when Apple released their new M series of processors, they had a fundamentally different architecture than before. We're talking about ARM versus x86, and for probably about a year there were some images for databases, for example, that were not readily available.

[00:16:38] Mauricio Dinarte: Generally speaking, as of today, you have pretty much cross-platform compatibility among multiple platforms and operating systems, but if there is something new, there might be a time to adapt. In some cases it is not DDEV itself, it is Docker or the underlying infrastructure that needs to be caught up. But even that is a relief because DDEV is always on top of these things. They are trying things ahead of us and making sure that they work and providing compatibility layers if necessary.

[00:17:18] Michael Meyers: Clearly, this provides a tremendous amount of benefits to organizations. We could probably do a whole show—and maybe we should—on the organizational benefits of this tooling: streamlining getting people up and running, making development processes faster, reducing errors, reducing the support burden, and so on.

[00:17:41] Michael Meyers: So it helps developers individually with a lot of challenges, and there's tremendous benefit for organizations to support and invest in it. We've talked a lot about the development use case for open source projects and for development inside an organization or an agency for clients.

[00:18:01] Michael Meyers: I want to ask about another use case, which is beyond that kind of day-to-day development in that context. Are there other benefits and ways of using these kinds of local environments?

[00:18:15] Mauricio Dinarte: Yes. One thing that you may know is that I am passionate about teaching, and I use these tools for trainings. One example: I will do a migration training. I prepare a repository in advance with two sites, one for Drupal 7, one for Drupal 11, everything configured. Run five commands, ten commands, and then you have a fully working Drupal 7 site with a database ready, prepopulated with user uploaded files, and a Drupal 11 site that is already installed and ready to execute the migration.

[00:19:02] Mauricio Dinarte: One of the things that I really like about these tools is that you can get things out of the box, and if that is all that you want, excellent—that's most of the time what I do. But if you really want to dig into the tools, tweak them, configure them, they are an awesome abstraction layer on top of the underlying infrastructure. In the end, you have full control, so you can customize them to the extent that you need.

[00:19:25] Mauricio Dinarte: Going back to the case of training again, before, at DrupalCon, either for the trainings that are offered as part of the program or during contribution sessions throughout the conference, we needed people to have a local environment. We would literally spend precious time, two, three, sometimes a full morning, just getting the tools set up and then start contributing or start teaching the training.

[00:20:02] Mauricio Dinarte: Now that we have these local development environments, we can either do it quicker or let people know in advance that they need to come prepared with these tools, which for the most part is install Docker, install DDEV, and we will do the rest during the conference. That makes things a lot more productive and we make better use of people's time.

[00:20:23] Michael Meyers: It's a really great abstraction layer. You did something similar with the data migration ebook. It is a book, and it walks you step by step through the process. You don't need to know a lot about the underlying technology. You can just install it in minutes and walk through the tutorial and learn about the migration process and not have to worry about every other aspect.

[00:20:55] Michael Meyers: It really enables people to do things that you might not be able to do otherwise. From a development standpoint, you mentioned Gander and the DDEV plugin. A lot of organizations don't have that kind of tooling set up, but there's tremendous benefit to running it locally. So even if your organization can't make it happen at the infrastructure and team level, you can still benefit from these tools and capabilities and ensure performance and scalability of your application as you do development.

[00:21:28] Michael Meyers: It's really interesting that in some ways it's more powerful than what you might have on production and easier for you to get up and running. And I think that's another great use case that people should consider: there are features you should be adding to your development process and toolchain that might not be used holistically as an organization.

[00:21:53] Michael Meyers: We've talked a lot about DDEV, but there are many tools out there that do this. Just at a high level, what are some of the more popular local environment tooling options?

[00:22:07] Mauricio Dinarte: This has evolved over time, and just for the record, I want to give credit to Jeff Geerling for many years of supporting Drupal VM, which back in the day was based on VirtualBox. Nowadays the most popular tools are Docker-based, and in that area, for Drupal specifically, we have three big ones. DDEV, Lando, and Docksal. There are more, but those are the most popular based on some developer surveys that are run by the Drupal community.

[00:22:43] Michael Meyers: And is there a clear leader, or is usage really fragmented?

[00:22:50] Mauricio Dinarte: Based on the 2025 results, DDEV is the most popular and Lando is the second one. When they break down the results, they point out that in some cases there are some countries that have a preference for one tool or the other, or depending on the team size, if you have a bigger team, you might notice a bigger need for this kind of tooling. So in those cases, there is a preference for one or the other, but otherwise they are pretty close in terms of usage.

[00:23:22] Michael Meyers: I remember historically DDEV was by far the most popular. And what was interesting is that it was also the least hated. If you looked at other tooling in this response survey, Homebrew might have 72% likes but almost 30% of the people really disliked it. DDEV had 93% of people who loved it; very few people were not a huge fan of the tool. So it had a really strong recommendation.

[00:24:02] Michael Meyers: And I think you can see that in the community. We sponsor a lot of different open source projects and tools, and the DDEV community—people email me every once in a while like “thank you so much for supporting DDEV,” and no one does that for the other platforms that we're supporting. There's this amazing, passionate community behind it, and it reminds me of Drupal and the Drupal community and the passion that you see there.

[00:24:30] Michael Meyers: We're big fans of DDEV, which is why we financially support it and use it as a team. There are a lot of tools, but for the sake of making this easier and clear to talk through, in the context of DDEV, can you give a deeper sense—what does it offer? Why is it that developers really love these tools?

[00:25:03] Mauricio Dinarte: DDEV is a Docker-based solution for local development environments, and it supports multiple languages. We are probably talking a lot about Drupal today, but it actually not only supports PHP, it also supports Node.js and it also supports Python.

[00:25:26] Mauricio Dinarte: Being able to support multiple languages means that it can also support multiple frameworks. Drupal and WordPress come to mind; I am usually switching between the two. But TYPO3, Craft, Flask, Laravel, you name it. If it runs on one of the supported languages, you pretty much can have it working in DDEV.

[00:25:43] Mauricio Dinarte: In fact, they offer quick start guides for many frameworks. This is always evolving, but the last time that I counted it was 27, and they are constantly adding more. This is one of the greatest benefits. All that tooling that I use for Drupal, I can switch to WordPress just by changing a configuration file, and being able to know that it exists, that I can rely on it, being familiar with it, is very powerful.

[00:26:16] Mauricio Dinarte: Beyond the technical part of DDEV, one of the highlights is that it has outstanding community support. Both Randy Fay and Stas Zhuk, who is the other maintainer, are incredible. It's like they are always there for you, and that level of support is one of the best I have seen in my whole development career.

[00:26:47] Michael Meyers: Docker is something that's come up a bunch of times now. One of DDEV's biggest wins in particular is hiding a lot of the complexity of Docker while still giving users flexibility and keeping that power. How does it achieve that balance?

[00:27:07] Mauricio Dinarte: They want to serve as many people as possible. Speaking about Docker, you can have multiple providers depending on your operating system. For MacOS you can have the official Docker Desktop, or OrbStack, Lima, Rancher Desktop, Colima. Some are commercial products, some are free, some are open source—a wide variety. But in the end, DDEV is trying to support as many as possible.

[00:27:29] Mauricio Dinarte: The UX, for the most part, is that your native package manager is going to get what you need. For Windows, you can have Docker Community Edition, Docker Desktop, and so on. At some point, we will discuss in more detail web IDEs or web environments, and GitHub Codespaces is yet another environment which is mostly web-based in which DDEV can run.

[00:28:09] Michael Meyers: As far as the development process goes, a lot of organizations are using some sort of cloud-based hosting platform, whether it's internal or through a provider like Pantheon, Platform.sh (which just rebranded as Upsun), Acquia, Amazee—there's so many options out there. Similarly, in the WordPress community, does DDEV provide any sort of specific integration with these? Does it make life easier when you're working with a platform provider, or does it not extend to that?

[00:28:42] Mauricio Dinarte: Yes, yes, of course. Let's give a specific example with Pantheon. You can log into your Pantheon account, create what is called a token, an authentication token, and this is all well documented. There is a file in which you put that token, and basically that's what you need to do.

[00:29:02] Mauricio Dinarte: From then on you do ddev pantheon get. You can get the database, you can get the files. Usually it is recommended that you only download from Pantheon to your local environment. If you want to shoot yourself in the foot, you can also push your local databases and your files upstream, but that is generally a bad idea. Again, ultimately you have the choice. It is copy one API key, one token, and then you have the commands to sync up and down databases and files.

[00:29:41] Michael Meyers: So if I'm using DDEV for my local development, what are some of the really powerful things that it enables me to do as a developer? We talked about project setup; it makes it super easy to run different versions of PHP and web servers. What are some of the other capabilities that I can expect?

[00:30:08] Mauricio Dinarte: In terms of setting up your environment, again, a configuration file and a couple of steps and you're ready to go. One thing that I want to highlight, and this is just a testament to the extra mile that DDEV maintainers put into the project: at some point, in terms of database servers, MariaDB and MySQL diverged. Basically MariaDB introduced a breaking change versus what MySQL would normally do, and DDEV created a compatibility layer so that if you import or export your database via the tools that DDEV provides, it doesn't matter if you were affected by that breaking change.

[00:30:53] Mauricio Dinarte: We can sometimes overlook these kinds of things because they just work, but there is a very thoughtful process in making them work under very different circumstances, even when a product introduces a breaking change.

[00:31:15] Mauricio Dinarte: Beyond the basics, beyond what is a hard requirement, we said you have database GUIs if you want to interact with the database. Adminer is one of them, phpMyAdmin is another one. These are web-based. You can also install, let's say on your local computer, Sequel Ace for macOS, and DDEV gives you a command that if it detects that Sequel Ace is available, it will not only open the program for you, but it is going to pre-populate the connection string so that it is ready to go.

[00:31:45] Mauricio Dinarte: You see your tables, you can start working directly with the tool, or you can get the connection details yourself and use whatever other tool you might want to use on your local machine.

[00:32:00] Mauricio Dinarte: For email, we said it comes with something called Mailpit, which is going to capture your mail out of the box. And again, the tools are always changing. Before we had Mailhog, that went unsupported; they replaced it with Mailpit, and you can just rely on something available for your needs.

[00:32:23] Mauricio Dinarte: On a Drupal day-to-day basis, you can execute Drush commands. You can use Node if you need to compile your theme. You can use terminal integrations, for example, if you are integrating with Pantheon, to interact with your Pantheon site within DDEV.

[00:32:50] Mauricio Dinarte: Something that is not often talked about is that DDEV allows you to have a fully working local development environment with very few tools set up on your local machine. For example, you can develop for Drupal without having PHP on your host. If you want, you can have PHP only inside of the DDEV container and that's fine, that works. It may be because of security—you don't want to have programs that you are not using—yet you still need to develop locally. So there is a lot of power and flexibility with the things that you can have available within DDEV itself.

[00:33:21] Mauricio Dinarte: In terms of debugging, we said Xdebug, XHProf, XHGui, all of that is available out of the box. If you want more advanced features like SPX for profiling, that is literally one DDEV command away to install the add-on, and then another one to turn on or turn off the feature itself.

[00:33:51] Michael Meyers: I love the name Mailpit. They did a great job with that. It's also a good example: you talked about how it used to be one tool and now it's Mailpit; new tools are constantly being introduced. In the Drupal world we have modules; in the WordPress world we have add-ons or plugins.

[00:34:14] Michael Meyers: DDEV is also extensible, and a lot of these things that you mentioned are add-ons. I would imagine other local development environments have similar things. In addition to some of what we talked about, what are some of the other add-ons that you are regularly relying on?

[00:34:35] Mauricio Dinarte: Something that I started to use recently is an add-on for AI-assisted development, which basically integrates Cloud Code within DDEV. Again, that is something that you can do manually yourself, but there is something already available that will do it for you.

[00:35:02] Mauricio Dinarte: It really depends on your project. For example, if you are working on databases, we talked about MySQL and MariaDB. You can have Postgres, you can have SQLite. There are add-ons for SQL Server from Microsoft. There are add-ons for MongoDB if that's what you're using.

[00:35:19] Mauricio Dinarte: For search, you know, Apache Solr, Elasticsearch, OpenSearch. For testing, there are plugins for Selenium, standalone Chrome, BrowserSync, Cypress, Playwright, and other frameworks. In different categories we have Redis, Varnish, Memcache, RabbitMQ, MinIO (which is the one that I mentioned as an S3 compatibility layer), Tailscale, which is a router/VPN.

[00:35:53] Mauricio Dinarte: There are also specific add-ons for Drupal development. There is one called Drupal Contrib, which is going to give you a lot of the tools that Drupal developers use to contribute code back to the community, especially around static analysis and code reviews.

[00:36:12] Michael Meyers: The biggest thing that I struggle with is you could listen to 10 minutes of this podcast and walk away thinking “these are awesome.” These tools are so amazing in what they do, they solve so many problems, provide so many economic benefits. I want to talk for a few minutes about why people aren't doing this, or why they're doing it but not really leveraging it anywhere near its capabilities.

[00:36:40] Michael Meyers: I understand that there are use cases where it just isn't possible. We work with a large Fortune 500 company that had massive security restrictions. They issued corporate laptops to everybody; they were locked down. You couldn't install anything. If you wanted to get something approved, something as simple as an editor, just a single program, an IDE, it was a multi-month process, a whole review board; it was intense.

[00:37:14] Michael Meyers: So local development just wasn't possible out of the gate with that organization. Those policies were extreme, and over time we helped them understand web development more clearly and a better approach to things, and things did get better over time. But out of the gate, for the first six to ten months, we had no choice but to do things with web-based editors.

[00:37:55] Michael Meyers: But that is hopefully an edge case, and again, they moved on over time with our support. Most organizations can do this, and yet we see that they aren't. Why? What are you seeing?

[00:38:02] Mauricio Dinarte: From conversations that I have with other community members, sometimes I hear that organizations give the opportunity or liberty to the developer to choose whatever they want. Some will use DDEV, some will use Lando, some will use something completely different. Point being, it is great to have a choice, but it is also less efficient. We go back to the problem: it works on my machine and it also doesn't work on my machine.

[00:38:36] Mauricio Dinarte: Being too flexible without providing some guidance, some basic guidance, can work against you. Another thing might be just lack of knowledge that something like this exists. The DDEV team tries to get the message across, and in my personal experience, I try to recommend this as much as possible because it saves so much time and so many headaches that, you know, please make yourself a favor and use DDEV or something similar.

[00:39:14] Mauricio Dinarte: Another thing is that some people really want to have control over everything, and that is not bad in itself, but at least be open to trying something new, trying something different. That is one of the things they mention in the Drupal Developer Survey: are you open to trying, are you thinking of switching your local development tooling?

[00:39:37] Mauricio Dinarte: So if you are not using anything, try something. We highly recommend it. Even if you want to have ultimate control, these kinds of tools can save you a lot of time but also can serve as a learning experience. As I said, getting a Redis server is one command and it is working. Then you can study how DDEV configures it out of the box, all the different options that you can configure, and maybe you learn more than if you are trying to do everything from scratch.

[00:40:12] Michael Meyers: We should retitle this episode “It works on my machine—but it doesn't work on my machine.” I hadn't thought about that. It's a really interesting and challenging problem. It seems like it divides into two main categories: individuals and their choices and how they want to work, and organizations that need to better understand the benefits of this tooling and why it's worthwhile to invest in supporting it as an organization and providing it to their resources.

[00:40:48] Michael Meyers: Two big problems that you would think wouldn't exist at this point. This is by far a best practice, and hopefully over time more and more people will see this.

[00:41:02] Michael Meyers: However—and I want to wrap up on this—there's potentially a big change in the works, or not in the works; it's been around for a while, that could change the game here. Local development isn't the only way to do this. People are using cloud-based editors in different scenarios for different reasons. What's your experience with cloud-based editors, and how do you see people using them?

[00:41:31] Mauricio Dinarte: Let's just start with Drupal, which is what we know the most. Now that Drupal.org has transitioned to GitLab, you have a fully fledged IDE available in your browser. Nowadays, it is possible to work on an issue completely from the browser, and this is very empowering.

[00:41:47] Mauricio Dinarte: Again, going back to DrupalCon contributions, if you are working on documentation, you don't need to install a local development environment at all. You can work everything through the web UI. If you are doing manual testing, again, you can use something like SimplyTest.me, or there are also web-based versions of tools similar to DDEV that you can spin up and have the equivalent, but via the browser.

[00:42:22] Mauricio Dinarte: In the browser you have the connection to the database, the web server, and everything. So that's Drupal. But even outside of Drupal, it really depends on the tech stack that you need. There are some projects that are more suitable for web-based-only development.

[00:42:45] Mauricio Dinarte: For example, if you're using React and you don't need a database, you're just connecting to an API endpoint. It is easier in general. There is less infrastructure that you need to account for, and it is easier to configure in a web-only environment.

[00:43:07] Mauricio Dinarte: We have seen this over time. People maybe don't even need a laptop anymore; a tablet could do. I have seen people, just for fun, work on open source from their phone and be able to complete the full cycle of reporting an issue to fixing it, all from the phone. Ultimately it is about being able to do it and having the ease of doing it.

[00:43:41] Mauricio Dinarte: Local development is not the only option, and these tools are becoming more and more powerful over time. Before it was only the IDE. Now you can have a database, you can have a debugger, you can have basically what DDEV offers and what many of these tools offer directly in your web browser.

[00:44:01] Michael Meyers: If you think about the benefits of the local development environment, in some respects onboarding is even faster. You don't even need the five minutes to install DDEV. You don't need that powerful local computer.

[00:44:17] Michael Meyers: When you were talking, I'm glad you said phone, because when you're talking about this, oh my God, I could be coding on my phone. That's amazing. It also democratizes technology. There are a lot of people in the world who have a phone but may not have a powerful laptop, and so having access to a web IDE with all these capabilities enables so many more people to access and participate in this, which is really amazing.

[00:44:47] Michael Meyers: Do you think that there's ever going to be a time, or how far are we from the time, where people aren't doing local development environments or where there's an inflection point and the majority of people are using more web IDEs than local development environments? Do you see that happening, and if so, when?

[00:45:02] Mauricio Dinarte: I can see this happening in the past, in the present, and in the future. A reference to the past: there are people just doing changes in production directly from the web server, and that is probably not a good idea, but it happens. Today we have talked about a couple of alternatives in which you have a fully fledged environment directly from your browser.

[00:45:30] Mauricio Dinarte: In the future, I can think of the evolution of AI and web-based IDEs that are going to give you all the tools that you need directly in the browser. I don't think that we are too far from being able to do a lot of these things directly in the browser.

[00:45:51] Mauricio Dinarte: Whether it is suitable for every project—probably something like a frontend JavaScript-based project will be there faster than something like Drupal that will require a database. But again, even that is possible. So I guess I don't have a definite answer. I know that it's possible and it's just going to get better and better over time.

[00:46:18] Michael Meyers: Yeah. Think about AI-assisted development, which is something that we do a lot of now, using it as a collaboration partner. AI is very resource intensive. There are some models that work locally, but it's going to be some time before you have the kind of power you need to do development in partnership with AI locally.

[00:46:40] Michael Meyers: So it may be that you are already dependent upon cloud services that you can't run locally. It's not like S3 where you can encapsulate it with an API and a service. In some senses, these web IDEs are almost more native. You're already on the web, why not use everything on the web?

[00:47:03] Michael Meyers: Interesting. This reminds me of something like BrowserSync Processing. It is a tool that basically lets you temporarily use a physical device for cross-device testing.

[00:47:18] Mauricio Dinarte: Again, it really depends on your need. Do you need to support iOS? Do you need to support Android? Do you need to support Firefox, Chrome, Edge, Safari?

[00:47:29] Mauricio Dinarte: The tools are going to be there. Whether you use them will depend on the needs of your project. The tools are going to be there depending on your project. You will be able to use them today, or maybe tomorrow, or maybe in a month from now. But I am sure that there will be an opportunity and something for everyone at some point.

[00:47:54] Michael Meyers: Mauricio, it was really great to see you. Thank you so much for joining me today, and thank you everybody for tuning in and listening.

[00:47:59] Michael Meyers: If you'd like to learn more about local development, we'll put a bunch of links in the show notes: Mauricio's favorite add-ons and information and links to some of the different development environments and tools that we mentioned. Please don't forget to subscribe to Tag1 Team Talks on your favorite podcast app or YouTube.

[00:48:21] Michael Meyers: If you have any suggestions, we love input, we love feedback. If there's something you want to see us cover, please reach out to us at [email protected]. You can check out our past Team Talks at tag1.com/ttt—that's three Ts for Tag1 Team Talks. Mauricio has a great number of episodes for the ebook on data migration, and we'll include a link to that as well. Thanks again for joining us. We'll see you soon.

[00:48:46] Mauricio Dinarte: Thank you.