Submission for the GitHub Finish-Up-A-Thon Challenge
What I Built
I built a Laravel Page Builder that allows developers to create and manage pages through a visual drag-and-drop interface.
Unlike most page builders that rely heavily on database storage, this project takes a different approach: page layouts are stored as JSON files directly in the filesystem.
The idea behind this decision was simple:
- Pages become portable
- Content can be versioned with Git
- Deployments become easier
- Developers can review page changes through pull requests
- No dependency on SQL or NoSQL storage for page definitions
The goal wasn't just to create another page builder, but to explore an alternative architecture for page composition within Laravel applications.
Current Features
- Drag-and-drop page builder
- Modular block-based architecture
- JSON filesystem storage
- Livewire v3 integration
- Editable headers and footers
- Import and export functionality
- Custom block support
- Multi-language support
The project is currently a working prototype, but it already demonstrates the core concept and architectural direction.
Repository
https://github.com/Justino-code/pagebuilder
Project Evolution
To make the progress made during the challenge transparent, I preserved two separate branches:
Before
https://github.com/Justino-code/pagebuilder/tree/before-changes
After
https://github.com/Justino-code/pagebuilder/tree/after-changes
These branches show the project's state before and after the redesign and refactoring work completed during the challenge.
Screenshots
Project screenshots can be found here:
https://github.com/Justino-code/pagebuilder/blob/main/docs/screen.md
The Story Behind the Project
This project actually started long before the challenge.
The original idea was to build a page builder centered around a filesystem-first philosophy, where page definitions would live as JSON files rather than database records.
While the concept was promising, the project eventually stalled and was left unfinished.
The GitHub Finish-Up-A-Thon provided the perfect opportunity to revisit the idea and determine whether it was worth pursuing.
Instead of trying to build every planned feature, I focused on validating the architecture, improving the internal structure, and delivering a functional prototype.
During the challenge I:
- Reworked the block architecture
- Improved page composition workflows
- Refactored major portions of the codebase
- Expanded customization capabilities
- Clarified the long-term direction of the project
The biggest achievement wasn't adding a specific feature.
It was proving that the concept works.
Today, the project has evolved from an abandoned experiment into a functional foundation that can continue to grow.
My Experience with GitHub Copilot
GitHub Copilot played an important role throughout the development process.
It helped accelerate implementation by assisting with:
- Laravel and Livewire boilerplate generation
- Refactoring repetitive code
- Block rendering improvements
- TailwindCSS UI development
- Exploring alternative implementations during redesign
Rather than replacing decision-making, Copilot acted as a productivity multiplier, allowing me to spend more time thinking about architecture and less time writing repetitive code.
Final Thoughts
For me, this challenge wasn't about shipping a finished product.
It was about finishing a phase of development.
Given the available time, I prioritized validating the idea and rebuilding the core functionality instead of focusing on perfect architecture or extensive polishing.
There is still a lot of work ahead, including improvements to structure, design patterns, developer experience, and overall refinement.
But the most important milestone has been reached:
The concept is validated.
What started as an abandoned idea is now a working prototype and a solid foundation for future development.
And that, for me, is exactly what the Finish-Up-A-Thon was about.