Have you ever wondered what happens behind the scenes when you press play on a podcast or audio app?
Most people see the finished product. They visit a website, tap a button, and immediately start listening. What they don't see is the work happening in the background to make that experience possible.
That realization hit me while building Daily Reading Podcasts, a web application that automatically provides the daily Catholic readings in audio format. On the surface, it looks simple. Visit the website, select the daily reading, and listen. Behind the scenes, however, there is an entire system working to collect, organize, and deliver the content.
In this post, I want to share the story behind the project, the technology that powers it, and some of the lessons I learned while building it.
What Is Daily Reading Podcasts?
The Daily Reading Podcasts project was created to make the daily Catholic readings easier to access and consume.
Not everyone has time to sit down and read the daily scriptures. Some people are commuting, exercising, working, or managing busy family schedules. Audio makes it possible to stay connected with the Word of God even when reading is not practical.
The goal was simple:
Provide the daily Catholic readings in an audio format that is easy to access from anywhere.
You can explore the project here:
Daily Reading Podcasts:
https://daily-mass-readings-audio.catholicdevotion.org/
What started as a simple idea became one of my favorite faith-based technology projects.
The Problem I Wanted to Solve
As both a developer and a person of faith, I often find myself thinking about how technology can remove barriers.
I noticed that many people wanted access to the daily readings but preferred listening rather than reading. Others wanted a simple experience without downloading large applications or navigating complicated menus.
I kept asking myself:
"What if someone could open a website and immediately listen to today's readings?"
That question became the foundation of the project.
Like many of my projects, the solution wasn't about creating something flashy. It was about creating something useful.
The Backend: The Real Engine Behind the App
When people visit the website, the front end is what they see.
The backend is what makes everything work.
In the case of Daily Reading Podcasts, the backend handles gathering the data, organizing it, and making it available through an API.
Why I Chose JavaScript
JavaScript has been one of my favorite tools for building web projects.
Since I already use JavaScript for websites, web applications, browser extensions, calculators, and various online tools, it made sense to use it for this project as well.
Using JavaScript allowed me to create an API that acts as a bridge between the data source and the application.
The API receives requests, processes information, and sends back the data needed for the website to function properly.
Without the API, the entire system would be much harder to maintain.
Where the Data Comes From
One of the biggest challenges when building any content-driven application is finding a reliable source of data.
For Daily Reading Podcasts, the readings are sourced from the United States Conference of Catholic Bishops (USCCB).
Each month, I manually update the API using information provided through RSS feeds.
This process may not sound exciting, but it is important.
Many developers focus only on writing code. In reality, maintaining accurate and reliable data is just as important as building the application itself.
A website is only as useful as the information it provides.
Over time, I have learned that successful projects are often less about technology and more about consistency.
Building the API
To keep the project organized, I created a dedicated API that serves the daily readings.
Current API Endpoint:
https://the-daily-bible-reading-audio-api.vercel.app/v1/today
The API allows the application to retrieve the latest reading information in a structured format.
One advantage of having a separate API is flexibility.
If I decide to build a mobile application, browser extension, smart speaker integration, or another website in the future, the same API can power all of them.
This is a lesson I have learned repeatedly while building software.
Whenever possible, it is worth separating the data layer from the user interface.
Doing so creates opportunities for future growth without requiring a complete rebuild.
Why I Made It Open Source
One decision I am particularly happy with was making the API open source.
API Source Code:
https://github.com/erickouassi/The-Daily-Bible-Reading-Audio-Api
Over the years, I have benefited tremendously from open-source software.
Many of the tools, frameworks, libraries, and resources I use every day were created by people who shared their knowledge freely.
Making this project open source felt like a small way to give back.
It also allows others to:
- Learn from the code.
- Suggest improvements.
- Fix bugs.
- Create their own versions.
- Build new applications using the same foundation.
I believe some of the best innovation happens when people collaborate.
Even if someone never contributes to the repository, they may learn something from it. That alone makes sharing worthwhile.
The Tech Stack
The project intentionally uses a simple stack.
Backend Language
- JavaScript
Data Source
- USCCB readings delivered through RSS feeds
Version Control
- GitHub
API Hosting
- Vercel
One lesson I have learned as a builder is that simple solutions are often the best solutions.
Not every project needs a dozen frameworks, multiple databases, and a complicated infrastructure.
Sometimes a lightweight solution is exactly what the users need.
Lessons I Learned From This Project
Building Daily Reading Podcasts taught me several important lessons.
1. Small Projects Can Have Real Impact
This project will never compete with the largest apps in the world.
That was never the goal.
If a single person listens to the daily readings more consistently because of this tool, then it has value.
I've learned that usefulness matters more than scale.
2. Maintenance Matters More Than Launching
Launching a project is exciting.
Maintaining it is where the real work begins.
Updating readings, monitoring functionality, fixing issues, and improving reliability are ongoing responsibilities.
A successful project is not something you launch once.
It is something you continue to care for over time.
3. Technology Can Support Faith
Many people see technology and faith as completely separate worlds.
I don't.
Projects like Daily Reading Podcasts remind me that software can be used to support spiritual growth, learning, and community.
Technology itself is neutral.
What matters is how we choose to use it.
4. Build First, Improve Later
One mistake many builders make is waiting for perfection.
I have done this myself.
Over time, I learned that launching a simple version today is usually better than endlessly planning a perfect version tomorrow.
Many of my projects started small and improved over time.
Daily Reading Podcasts is no different.
Practical Takeaways for Developers
If you're thinking about building your own web application, here are a few lessons from this project:
- Start with a real problem.
- Keep the first version simple.
- Separate your data layer from your user interface.
- Choose reliable data sources.
- Don't underestimate ongoing maintenance.
- Consider open sourcing your work.
- Focus on usefulness before complexity.
Most successful projects are not successful because they use the newest technology.
They succeed because they solve a real problem consistently.
Final Thoughts
Building Daily Reading Podcasts has been one of those projects that reminds me why I enjoy creating software.
It combines several things that matter to me: faith, technology, learning, and service.
As a developer, I enjoy solving technical challenges. As a builder, I enjoy creating useful tools. And as someone who believes in lifelong learning, I enjoy sharing what I discover along the way.
The project is far from perfect, and there is always room for improvement. But that is true of almost every meaningful project.
What matters is that it serves a purpose and helps people engage with the daily readings in a simple and accessible way.
Sometimes the most rewarding projects are not the ones that generate the most traffic or revenue. They are the ones that quietly help people every day.
So whether you're a developer exploring APIs, a fellow builder looking for inspiration, or someone interested in daily Catholic readings, I hope this behind-the-scenes look has been helpful.
What is a project you've built, or would like to build, that combines technology with something personally meaningful to you?