Have you ever opened a prayer app and realized it didn't quite do what you needed it to do?
That was exactly my experience with the Rosary.
As a Catholic, I know that the Rosary is much more than a collection of prayers. It is a spiritual practice centered on meditating on key moments in the lives of Jesus and Mary. Depending on the day of the week, different mysteries are prayed. On top of that, some Sundays follow different mystery schedules based on the liturgical season.
For a long time, I found myself asking a simple question:
"Which mystery should I be praying today?"
It sounds like a small problem, but when you're trying to build a consistent prayer habit, even small obstacles can become frustrating. That question eventually led me down a path that resulted in the creation of the Daily Rosary Web App.
Today I want to share the story behind it, the challenges I encountered, and what I learned throughout the process.
Understanding the Real Problem
Many Rosary apps already existed when I started exploring the idea.
At first, I assumed I would find one that perfectly matched what I was looking for. Instead, I discovered that most of them were relatively static. They displayed prayers well enough, but they often required users to already know which mystery should be prayed on a specific day.
That may not be a problem for lifelong Catholics who have memorized the schedule.
But many users are converts, beginners, returning Catholics, busy parents, or people simply trying to grow in their faith. They may not remember whether today is Joyful, Sorrowful, Glorious, or Luminous Mysteries.
Then there was another challenge.
Sundays are not always the same.
The mystery prayed on Sunday can change depending on the liturgical season, such as Advent, Lent, Easter, or Ordinary Time. Once I realized this, I knew a simple static solution would never be enough.
The app needed to think for the user and automatically determine the correct Rosary for the day.
My First Step: Looking for an API
Whenever I start a new project, I try not to reinvent the wheel.
Before building anything, I searched for existing Rosary APIs that could provide the information I needed. My hope was to find a reliable data source that already handled the liturgical calendar and mystery schedules.
Unfortunately, I couldn't find one that met my requirements.
Some solutions were incomplete.
Others were outdated.
A few simply didn't provide the information necessary to determine the correct mysteries dynamically.
At that point, I had two options:
- Abandon the idea.
- Build the missing piece myself.
I chose the second option.
Creating My Own Rosary API
Since I couldn't find a suitable API, I built one.
At first, the solution was fairly straightforward. I created a custom API that provided the mystery schedule and related information needed by the app.
The system worked.
The app displayed the correct mystery.
The user experience improved.
Problem solved, right?
Not quite.
I quickly realized that maintaining accuracy would require updating the data regularly. Liturgical calendars change every year, and I didn't want to manually adjust large portions of the system every time a new year arrived.
I needed something more sustainable.
This is a lesson I've learned repeatedly while building websites, calculators, browser extensions, and web applications:
The first version solves the immediate problem. The later versions solve the maintenance problem.
Finding an Official Source
Accuracy matters, especially when building religious tools.
I didn't want users wondering whether the information was correct. I wanted the app to rely on a trusted source whenever possible.
That's when I turned to the United States Conference of Catholic Bishops (USCCB) liturgical calendar.
The calendar provided the information necessary to determine seasons and calculate the appropriate Rosary mysteries throughout the year.
Instead of relying solely on manually maintained logic, I could use official calendar data as the foundation.
This gave me greater confidence that the app would remain accurate and useful.
The Spreadsheet Solution
Some of the most practical solutions are surprisingly simple.
Once I gathered the calendar information, I began organizing the data in a spreadsheet. The spreadsheet became a central source for important liturgical information required by the app.
From there, I connected the data to the web application using a free tool created by Ben Borgers.
This approach offered several advantages:
- Simple maintenance
- Easy updates
- Clear organization
- Less custom code
- Better long-term flexibility
As developers, we often assume every problem requires a complex technical solution.
In reality, some of the best systems are built from simple, reliable components working together.
Bringing Everything Together
Eventually, all of the pieces came together.
The Daily Rosary Web App automatically determines the correct Rosary mysteries based on the date, the day of the week, and the liturgical season.
A user can simply open the application and start praying.
No guessing.
No searching online.
No checking a separate calendar.
The app does the work behind the scenes so the user can focus on prayer.
That was always the goal.
Technology should remove friction, not create more of it.
Why I Made It Independent and Open Source
Over the years, I've built websites, browser extensions, calculators, APIs, and various digital tools.
One lesson I've learned is that ownership matters.
I deliberately chose to host the project independently. I didn't want the future of the application tied to a platform I couldn't control.
I also decided to make the project open source.
Why?
Because I know there are other developers who may want to build something similar.
Maybe they need different features.
Maybe they serve a different audience.
Maybe they want to create their own Rosary application in another language or for another country.
Rather than forcing everyone to start from scratch, I wanted to provide a foundation that others could build upon.
That mindset has guided many of my projects.
Sometimes the goal isn't just to create a tool.
Sometimes the goal is to create a starting point.
If you're interested in the code, you can explore my GitHub repository and even fork the project to create your own version.
Future Improvements
One feature I'm currently considering is adding liturgical colors.
At first, it sounds simple.
But like many things in software development, the deeper you look, the more complex it becomes.
Certain days may have multiple liturgical colors or special celebrations that affect the expected color. Because of that, I don't want to hard-code the information.
I want the feature to remain dynamic, just like the mystery calculations.
Whenever I build a new feature, I try to ask myself one question:
Will this help users, or will it simply make the app more complicated?
The answer isn't always obvious.
What Building This Project Taught Me
The Daily Rosary Web App reinforced several lessons I've learned throughout my journey as a developer and entrepreneur.
First, many worthwhile projects start with a personal problem.
Second, if a solution doesn't exist, sometimes you need to build it yourself.
Third, maintaining a project is often harder than creating the first version.
And finally, simplicity usually wins.
Users don't care how sophisticated the architecture is.
They care whether the tool helps them accomplish what they came to do.
In this case, that means helping people pray the Rosary with confidence and consistency.
Practical Takeaways for Builders
If you're building your own website, app, extension, or digital product, here are a few things I'd recommend:
- Start by solving a real problem.
- Don't assume existing solutions meet everyone's needs.
- Use official and trusted data sources whenever possible.
- Think about maintenance before adding complexity.
- Build for the user, not for your portfolio.
- Keep improving, but don't overcomplicate things.
- Consider making your work open source when it can help others.
These principles have helped me across many different projects, and they definitely shaped the development of the Daily Rosary Web App.
You can explore the project here:
- Daily Rosary đź“ż: https://dailyrosary.catholicdevotion.org/
- The Rosary API: https://the-rosary-api.catholicdevotion.org/
- GitHub: https://github.com/erickouassi
Final Thoughts
Looking back, this project started with a simple question: "Which mystery should I pray today?"
That small frustration turned into an API, a web application, an open-source project, and a tool that helps others pray more easily.
It's another reminder that some of the best projects don't begin with a business plan or a market analysis. They begin with a real problem experienced by a real person.
For me, that person happened to be me.
And sometimes, that's enough reason to start building.
Have you ever created a tool, website, or system because the existing solutions didn't fully meet your needs? I'd love to hear what you built and what you learned along the way.