In my early days developing cloud applications, I faced significant challenges trying to code, test and fix bugs efficiently. Pushing code to remote environments created lag while waiting for cloud build and deployment cycles. This destroyed developer productivity and disrupted any sense of coding flow.
Over time, I realized that cloud developers should focus on leveraging local environments as much as possible. Building and testing locally are far faster than remote cloud development. As head of engineering at Nitric, I’m obsessed with optimizing cloud developer workflows by empowering fast, flexible local coding. As we develop our cloud-aware application framework, we’re continually asking, “How can we enable developers to move fast locally?”
What Makes Local Development Great?
Here are some key elements that make local development experience crucial to productive cloud development:
Fast Feedback Loops
The number-one priority is getting rapid validation of changes through testing and debugging without waiting on remote build cycles. I always say, “The faster the iteration, the better the developer experience.” Modern environments allow building, testing and running services locally, tightening feedback loops. I vividly remember the frustration caused by 20-minute cloud build cycles; they led to significant productivity loss due to frequent context switching. With subsecond local execution, I can maintain focus and productivity.
Frameworks that excel at providing quick feedback include new web frameworks like Astro, which uses Vite for fast module replacement. This speed remains consistent, regardless of the app’s size.
Cost Effectiveness
No cloud bills! I joke with our finance team, “We can develop all day for the low cost of some pizza.” Ballooning cloud costs from excessive debugging cycles can create extreme financial challenges. By optimizing locally, we can innovate without worrying about the budget, and tools like Supabase with its local development environment for database-driven web applications help keep expenses in check.
Ease of Debugging
Stepping through code locally makes finding bugs far easier. I tell junior engineers, “Let the debugger be your friend.” Rather than parsing through logs, I can set breakpoints, inspect variables and walk the execution path to fix issues quickly. My first bug hunts involved redeploying to add print statements — local debugging changed everything.
In today’s development landscape, tools like Playwright for end-to-end testing and Vitest for fast local testing further enhance the debugging process, empowering developers to catch and address issues efficiently.
Offline Development
You don’t want to be tethered to the internet for all coding. I’ve had too many experiences overseas struggling with spotty hotel Wi-Fi. Local execution gives flexibility to code anywhere. I tell my team, “Always be prepared to develop offline.” I think back to long flights, debugging connection issues rather than product bugs. Our local setup means I can now build features from 30,000 feet in the air, anywhere in the world.
Leveraging Local Resources
A local environment fully uses the local file system, CPU, memory and caches for speed. I remind my engineers, “Your local machine gives you power — use it.” Early in my career, I was limited to small data samples and constrained cloud resources. With blazing-fast SSDs, multicore CPUs and ample RAM on our high-end laptops, we can build complex systems locally and iterate quickly.
Security
Keeping data local enhances security by avoiding cloud exposure. As I say, “Local data stays local.” I’ve seen vulnerabilities introduced by copying sensitive data to shared cloud accounts too early. Developing locally allows us to secure the entire life cycle, from prototype to production, as long as the best data security practices are being adhered to by all developers and devices.
Customization
Tailoring tools and configs boost individual productivity. As I tell new hires, “Make your local dev environment your own.” Early on, I had to use whatever IDE and messy scripts the team chose. Configurable workflows enable me to tune my local setup to match my style and flow state. A coder’s environment is personal, and versatile code editors like Visual Studio Code (VSCode) set the gold standard for customization, allowing developers to fine-tune their environment with extensions, themes and configurations that align perfectly with their preferences and needs.
Local Versus Remote Cloud Development
Not all teams are sold on the benefits of local development. Some areas still spark healthy debates:
Cloud simulation: Some believe local development isn’t good for cloud development because you do not get sufficient high-fidelity cloud simulation/emulation. You can emulate more cloud services if you are not developing locally. I believe the savings with complexity are worth building locally. You can build quickly and then conduct end-to-end testing in the higher-fidelity environment. That level of fidelity is a hindrance while you are actively building.
Standardization: Some believe there is no control over standards on local machines with a lot of different setups. I believe guidelines, consistent review and approval processes are sufficient. Make it easy for developers to follow the standards and give them the freedom to code locally with some customization for greater productivity and satisfaction.
Isolation: Some believe that local development can result in isolation, limiting communication and potentially causing issues like misunderstandings and delays. I believe local development encourages ownership, autonomy and deep focus, facilitating innovation and creative problem-solving while still allowing structured collaboration to address potential downsides.
Data sets: Some believe local development does not give access to large data sets needed for realistic training of certain projects. I believe in leveraging tools such as ChatGPT, Faker, database seeding and Snaplet to create mock data, enabling effective testing and development without relying on extensive real data sets.
Integration testing: Some believe building in a cloud environment is important when integrations are involved because you need to know if they’ll work in a cloud environment. I believe you do have to test in the cloud, but you don’t have to build there. It’s quicker to integrate locally, see them break, and finish building locally. Then you can do an end-to-end test when you’re done. Building in the cloud is slow. If you just test there, it’s much faster.
The Future of Local Cloud Development
While local cloud development is highly productive today, I’m excited by future possibilities that will further optimize local workflows.
For example, advanced virtualization and container techniques will allow the simulation of cloud environments locally with even greater fidelity, without compromising speed. Developers will be able to validate against realistic cloud scenarios locally.
AI assistance will help automatically configure tailored local setups optimal for each developer’s needs and style. Intelligent tools can analyze our workflows and customize environments to match.
Improved snapshotting and branching capabilities will make isolating features locally easier while still enabling collaboration across teams. Developers will be able to encapsulate work without causing silos.
As hardware expands, we’ll be able to condense even large-scale cloud systems onto local machines and run robust integration tests at scale locally. Entire platforms can be simulated locally.
The goal is to provide developers with seamless coding, testing and debugging workflows where local environments “just work” so they can stay focused on building.
Local Cloud Development with Nitric
At Nitric, we believe local cloud development is the most productive approach, and we make specific choices in our tools to optimize local workflows for cloud developers. For example, our local dashboard enables testing cloud APIs, schedules and services directly on a developer’s machine without any dependencies. We also support multiple languages in our open source framework so developers can use their preferred stack for the local development of cloud apps.
Our consistent SDKs simplify collaboration by abstracting cloud differences. Developers can seamlessly switch between local and remote execution without worrying about specific cloud details because Nitric ensures compatibility across cloud environments. Check out this short video, “Debugging Made Easy with Nitric Start” to see how easy local cloud development is with Nitric.
We will continue gathering data and feedback to refine local cloud dev workflows iteratively. Come chat with us about your ideas for improving local cloud development.
This article was originally published on The New Stack.
