Pendulum Photography

March 7, 2026 · 3 min read · craigpars

Pendulum Photography

An Early Experiment: Laravel Rendering WordPress Content

Before this website existed, I built a small experiment that explored a question I had while learning Laravel:

Could Laravel render a blog while WordPress handled the content?

The result of that experiment is found in this github repo:

https://github.com/CraigThomasParsons/WordpressInLaravel

It’s a simple prototype, but it helped me understand how different systems can work together.
This is very out of date, and really isn’t functional anymore

The Idea

WordPress is excellent at content management.
Laravel is excellent at application architecture.

Instead of using WordPress to render the entire website, I wanted to see if I could use it purely as a content source while letting Laravel handle the frontend.

In other words:

WordPress would manage posts, authors, and media.
Laravel would handle routing, rendering, and the user-facing website.

How It Worked

The experiment used WordPress as a headless CMS.

The workflow looked like this:

  1. In WordPress the client entered blog posts and photos.
  2. then the WordPress Database is accessed by the Laravel App.
  3. The Laravel application Rendered blog pages, and displayed the photos in a gallery.

Laravel would fetch posts from WordPress using the database connection and then render them using Blade templates.

This approach meant the public website didn’t rely on WordPress themes or plugins to control the presentation layer.

Why I Wanted to Try This

At the time I was learning both Laravel and WordPress, and I was curious about how modern web architecture was evolving.

Many developers were beginning to experiment with decoupled CMS architectures, where content systems and frontends are separated.

This approach can offer several advantages:

  • better control over application structure
  • more flexibility for the frontend
  • easier integration with other tools and systems

Building this prototype helped me understand how those pieces fit together.

What I Learned

Even though the project was small, it taught me a lot about:

  • REST APIs
  • Laravel routing and controllers
  • separating content from presentation
  • designing flexible web architectures

It also gave me the idea to eventually build a more structured version of this concept.

The Next Version

This experiment eventually evolved into the architecture behind the blog you’re currently reading.I use blog posts from wordpress for the portfolio items.

In the newer version:

  • WordPress is used strictly for content authoring
  • Laravel owns the public website
  • posts can be synced and cached locally
  • the site can continue working even if WordPress goes offline

    WordPress
    ↓
    WordPress REST API
    ↓
    Laravel application
    ↓
    Rendered blog pages

In other words, the simple experiment became the foundation for a more robust blog platform.

Why I Keep Projects Like This

I originally built this for a friend and it was a very useful way to showcase that I can build useful websites for professionals. Unfortunately for me she no longer wants the website and all I have now is Repo that really isn’t going to be used by anyone anymore.

However, not every project needs to be perfect.
Sometimes the value is in the experiment itself.

This early prototype helped me understand how to design better systems, and it’s part of the learning process that led to the projects I’m building today.

If you’re interested in the newer version of this system, you can explore the architecture and projects documented on this site.

About