Chapter 1: The Importance of Incremental Development

Inspiring narratives about success often encourage a leap into complex projects. However, emulating others may lead to attempts at building solutions that aren't quite ready for launch.

This week, I’m attending a conference centered on serverless architecture in London, surrounded by some of the brightest minds in the field. It's been a pleasure reconnecting with old friends from re:Invent and making new acquaintances.

During a session, I reflected on the prevalent serverless content out there. Most resources either cater to beginners or delve into highly advanced topics that require years of experience to comprehend. While both ends offer valuable insights, those of us situated in the middle often feel underserved.

Relying solely on beginner tutorials may stifle the growth of our application's capabilities, while diving into advanced materials too soon might lead to overly complex and unnecessarily optimized code that prepares us for scenarios we may never encounter. So, what should those of us who aren't beginners or experts do?

Focus on What Matters

In essence, "what matters" is centered around addressing your business challenges. Specifically, how can you tackle these issues in a way that differentiates you from your competitors? What unique value do you bring to your solution?

Identifying a unique approach to solving a business problem is far more critical than having flawless, self-optimizing serverless code from the start. Remember, software is never truly finished. Adopting a mindset of continuous improvement is crucial as you move beyond introductory courses on Lambda.

I recently came across a tweet discussing a presentation by Boris Tane, who emphasized the concept of incremental delivery.

His presentation highlighted the idea of consistently enhancing a product. Rather than attempting to create a complete car from scratch, start with something simpler—a skateboard. Gradually improve the design to a scooter, then a bike, and eventually a motorcycle. This way, your skills will evolve, enabling you to produce a high-quality car in less time than if you aimed for that from the outset.

By starting small and delivering a solution that effectively addresses a business problem, you get your product into the hands of consumers sooner. This approach also helps you gain expertise in the relevant area, informing design decisions that will positively influence both customer experience and the architecture of the final product.

Embracing Iteration in Development

I've frequently discussed the significance of iteration in the development process, sharing my own experiences with serverless technology. The most effective strategy I've found is to implement solutions, refine them, and improve upon them.

Start by addressing the business problem directly. Be resourceful. Move quickly and take an experimental approach. Learn the technicalities involved in resolving the issue at hand.

Once you've established a workable solution, prepare it for long-term use. Incorporate observability, rectify defects, and optimize the code.

Afterward, build upon your initial success. Enhance your application by adding features and applying the lessons learned along the way.

Case Study: PostNL's Event-Driven Architecture

For instance, in November 2022, Luc van Donkersgoed appeared on the Real World Serverless podcast, discussing how PostNL created their event-driven architecture. He explained their development of a custom event broker designed to validate and route events effectively. They also built a schema registry to manage breaking changes, event versioning, and track consumer subscriptions.

The sophistication of their approach was impressive. Inspired, I was eager to replicate it for my project, given that I had a similar use case and it was a well-established pattern.

However, my team lacked the extensive experience that Luc's team possessed. The domain expertise required took years to cultivate, so I opted for a more gradual approach.

We decided to leverage EventBridge initially, avoiding the need to create our own event broker. As we were just starting to adopt an event-driven architecture, it made sense to allow AWS's managed service to guide us. Our initial implementation of publishing and subscribing to EventBridge events served as our "skateboard."

Once we were comfortable with asynchronous workflows, we began validating schemas. I developed an internal npm package to validate event payloads against fixed JSON schemas before publishing messages to the event bus. Event consumers also utilized this package to ensure payload validation.

Looking ahead, we aimed to create a portal for developers to register their events rather than hardcoding them in an npm package. Eventually, we planned to construct the event broker to coordinate all components.

Regardless of our progress, one constant remained: we always prioritized solving the business problem. We simply kept refining our approach.

Conclusion: The Journey of Learning and Improvement

Gaining expertise takes time, especially in fast-evolving fields like serverless technology. Often, the best way to discover effective patterns is through personal exploration. Don't view the impressive talks, blogs, and podcasts as mandates to "do it this way immediately." Instead, see them as reference points to guide your unique journey.

It's easy to become enamored with the achievements of community leaders, but remember that their success did not come overnight. They learned through their own trials, much like the rest of us.

Absorb as much valuable content as you can. Learn from it and use it to inform your decisions, but be cautious not to take on more than you can handle. You might find yourself wishing you had focused on delivering that skateboard after all.

Happy coding!

Video Description: Explore insights from the book "Build What Matters," examining how to prioritize effective solutions in product development.

Video Description: Ben Foster discusses how to achieve vision-led product management, focusing on building what truly matters in your projects.