Search for a command to run...
With over a decade of hands-on experience, I specialize in building robust web applications and scalable software solutions. My expertise spans across cutting-edge frameworks and technologies, including Node.js, React, Angular, Vue.js, and Laravel. I also delve into hardware integration with ESP32 and Arduino, creating IoT solutions.
No comments yet. Be the first to comment.
Hello again! Welcome to Part 5 of my homelab journey series! After setting up my Lenovo M920 Tiny with Proxmox (as you saw in Part 4), I've been exploring various self-hosted applications. Today, I want to share what has become my absolute favorite s...
Hello the world, I'm excited to share BackPair with you today – a desktop application I developed to streamline local backups between folders and devices. This project emerged from two needs: simplifying my own backup process for my PC and homelab, a...
Hello again! After playing around with my Raspberry Pi 4 setup for a while (as you saw in my previous articles), I started feeling the itch to try something with a bit more muscle. Don't get me wrong, the Pi has been amazing for getting my feet wet i...
Hello again! After setting up my Raspberry Pi with various services and getting everything to run smoothly, another need popped into my mind—creating a reliable photo backup solution at home. Sure, we all rely on cloud services to store our photos an...
YaffaLab: Learn Web Dev, Data Science, and Master Tech Skills
41 posts
As developers, we're surrounded by an abundance of tools and libraries designed to make our lives easier. From React component libraries to code generators, these tools save us countless hours of repetitive work. But have you ever built one yourself? I did—and it transformed the way I code, collaborate, and think as a developer.
When I first started building custom libraries and generators, I wasn't just trying to speed up my workflow—I was unknowingly embarking on a journey that dramatically leveled up my skills. Creating tools forces you to think about reusability, design patterns, and maintainability in ways that day-to-day project work often doesn't require.
After working on numerous collaborative projects throughout my career, I felt compelled to share the invaluable lessons I've learned. My latest collaboration involves a ReactJS library that perfectly exemplifies why I'm so passionate about the power of working together. These experiences building developer tools inspired me to write this article and share these insights with both beginners and professionals alike.
In this article, I'll share insights from my experience developing two tools that have reshaped my development workflow: JERYO (a ReactJS component library built in collaboration with @Jérémy) and IyaGenerator (a Laravel & InertiaJS package). Both started as solutions to specific problems but evolved into comprehensive toolkits. They not only saved time but also became vehicles for learning and collaboration.
Whether you're a seasoned developer looking to optimize your workflow or a student eager to deepen your understanding of software design, I hope my experiences will inspire you to consider building tools—not just as a means to an end, but as an invaluable learning opportunity.
Building your own developer tools isn’t just about solving immediate problems—it’s one of the most effective ways to deepen your technical knowledge and programming skills. Tools like Jeryo and IyaGenerator provided learning opportunities that regular project work couldn’t match.
One of the first challenges you’ll face when building a tool is deciding what should be configurable versus hardcoded. For Jeryo, we had to identify common dashboard patterns that could be reused across different projects. This forced us to think beyond the immediate use case and consider:
Which components need to be customizable?
What default behaviors make sense for most scenarios?
How can we make our API intuitive while maintaining flexibility?
This process of abstraction is a fundamental skill. You start seeing patterns where before you only saw one-off solutions. That shift in thinking has improved the quality and consistency of my code across all projects.
Building libraries pushes you to implement design patterns you might have only read about. When developing Jeryo's form composers, we naturally gravitated toward the Composite Pattern, which allowed us to treat individual form fields and groups of fields uniformly. This made handling complex nested forms much easier.
For IyaGenerator, I implemented a Template Method Pattern. It let me define the overall structure of code generation while allowing for customization of specific sections. This ensured that each generated component followed a consistent structure, yet remained flexible for different use cases.
These weren’t academic exercises—they were practical, hands-on solutions to real problems. Implementing design patterns in tools you’ll actually use makes abstract concepts concrete and unforgettable.
Perhaps most importantly, building tools shifts your perspective from user experience to developer experience. You start asking:
Is this API intuitive for other developers?
How comprehensive should the documentation be?
What are the common pitfalls users might encounter?
This empathy for fellow developers pushes you to write clearer, more maintainable code in all contexts—not just when building libraries.
One of the most valuable lessons I've learned in my development journey is that collaboration brings perspectives you simply can't see with your own eyes. When working with others, you gain access to different approaches, techniques, and solutions that might never have occurred to you working alone.
This became especially apparent when collaborating on our ReactJS/TypeScript library designed to facilitate dashboard building. What began as a straightforward project evolved when we discovered we had different visions for its direction. Rather than seeing this as an obstacle, we recognized it as an opportunity. These divergent perspectives ultimately led us to a much bigger idea that we're now excited to pursue together.
The benefits of this collaborative approach extended far beyond the technical aspects. Working with another developer pushed me to:
Articulate my design choices more clearly
Consider edge cases I hadn't encountered individually
Question assumptions I might have otherwise missed
Find elegant compromises that satisfied multiple needs
These different viewpoints created a natural system of checks and balances that improved the final product in ways that would have been impossible working solo. The library became more robust, flexible, and ultimately more useful because it incorporated multiple perspectives from the start.
While learning is a valuable byproduct, it’s usually the practical benefits that spark the initial development of custom tools. They shine in scenarios where off-the-shelf solutions fall short or require too much customization.
When working in teams, maintaining consistent coding standards and architectural patterns can be challenging. Custom tools can bake these best practices directly into generated code or reusable components.
With Jeryo, we embedded our team’s preferred approaches to:
Form validation
Error handling
State management
Component composition
Similarly, IyaGenerator produces code that follows our established architectural patterns. This ensures consistency, even as team members come and go.
Generic tools often struggle with industry- or domain-specific needs. Custom tools, on the other hand, can directly incorporate specialized knowledge.
For example, IyaGenerator includes templates for common business entities like users, products, and orders, complete with relationships and validation rules. This domain expertise makes it particularly valuable for certain types of applications.
The most immediate benefit of custom tools? Speed.
What used to take days can now take hours—or even minutes. This acceleration enables:
Faster prototyping
More time for testing and refinement
Quicker response to changing requirements
Lower development costs
With IyaGenerator, I can deploy a complete admin interface with full CRUD capabilities for a new entity in under five minutes—including database migrations, backend logic, and frontend components. This level of efficiency has transformed my development workflow.
Building tools isn't just a technical endeavor—it's a social one. Collaborating on developer tools revealed the unique benefits of working together on these projects.
For junior developers, collaboration offers a window into the real world of professional development. It challenges you to:
Explain and defend your code choices
Understand different coding styles
Learn industry best practices
Develop crucial communication skills
Build a professional network
For seasoned professionals, collaboration continues to provide value through:
Cross-pollination of ideas
Accountability and motivation
Shared workload during complex projects
Continuous learning through knowledge exchange
When multiple developers bring different experiences and preferences to the table, these diverse perspectives push the project forward:
Architectural decisions become more thoroughly vetted
UX considerations become more comprehensive
Documentation improves as different learning styles are considered
Edge cases are identified earlier in the development process
Solo projects often stall when life gets busy. Collaboration creates a natural accountability system:
Regular check-ins keep things moving forward
Shared ownership increases commitment
Different strengths help overcome obstacles
One person's enthusiasm can reignite motivation in the other
Even small tools can build communities. My libraries started as tools just for my teams, but once shared with colleagues, they sparked valuable conversations and contributions.
That small community provided:
Helpful feedback
Feature suggestions we hadn't considered
Edge case identification
A sense of shared purpose
When developed collaboratively, even simple tools can become focal points for ongoing learning and professional connection.
The journey of creating custom tools like Jeryo and IyaGenerator has been transformative. Yes, they save time—but the deeper benefits of learning, collaboration, and standardization have proven even more valuable.
Building your own developer tools offers multiple layers of value:
Learning acceleration: You’ll master reusability, design patterns, and advanced language features in a practical context.
Workflow optimization: Custom tools tailored to your workflow eliminate repetitive work and standardize best practices.
Collaborative growth: Working with others creates opportunities for knowledge sharing and builds stronger professional relationships.
You don’t have to build a framework to get started. Begin with a small utility that solves a specific pain point in your workflow. As you gain confidence and see the benefits, you’ll naturally expand its capabilities—or create complementary tools.
The Jeryo library started as a simple collection of form components before evolving into a complete dashboard solution. IyaGenerator began with basic CRUD generation and grew to handle complex relationships and custom deployments.
If you’ve ever found yourself thinking “there has to be a better way,” that’s the perfect place to start. Your next favorite tool might be the one you build—so why not get started today?
