How I actually learned this work

I’ve spent about seventeen years learning this work the long way: reading docs, shipping real sites, and fixing what broke. I’m a self-taught WordPress developer—plus plenty of on-the-job learning in marketing web and related tools. No bootcamp fairy tale. Just practice.

All of that time has been in-house web work, and it started in higher-ed marketing. Nobody handed me a curriculum, and that is the plain meaning of being a self-taught WordPress developer. I learned by doing the job in front of me, one site and one problem at a time. This post covers how that happened, what it taught me, and how it shapes the custom WordPress work I do for shops and agencies today.

Early tools: Dreamweaver and hand-coded ASP

Before 2010, most of my web work lived in Dreamweaver and hand-coded ASP. That was the practical stack where I learned how pages, forms, and server-side logic fit together. It wasn’t glamorous, but it taught fundamentals I still use: clear structure, careful edits, and respect for what has to keep working after you leave.

Working that close to the code meant I had to understand what each page was doing. If a form stopped sending, I had to find out why. If a layout broke in one browser, I had to fix it by hand. There was no page builder to fall back on.

That habit of reading the code before changing it has stayed with me. It is one of the most useful things a self-taught WordPress developer can pick up early, because it makes every later tool easier to learn.

First webmaster job at Germanna Community College

My first webmaster role was at Germanna Community College, in the marketing and public information office. That’s where on-the-job learning got serious. I learned marketing alongside advanced web work—messaging, audiences, deadlines—and how a public college site has to hold up for prospective students, faculty, staff, and alumni.

Being in a marketing office, not an IT office, shaped how I think about websites. The site was there to help people find what they needed and take the next step. Every technical choice had to support that. It is a view I still hold as a self-taught WordPress developer working with marketing teams.

ASP to PHP and WordPress on WP Engine

Over time the stack moved from ASP toward PHP and WordPress, hosted on WP Engine. Day-to-day edits shifted from Contribute toward WordPress itself. The college site redesign is when my interest in WordPress really took hold: a CMS marketers could use, themes and plugins we could maintain, and a workflow that matched how the office actually published.

Moving to WordPress meant learning a new set of rules. I spent a lot of time in the WordPress Theme Handbook, learning how templates, the loop, and hooks work. I tested what I read on real pages and kept notes on what worked.

That redesign was the point where I stopped thinking of myself as someone who edits web pages and started thinking of myself as a self-taught WordPress developer.

What higher-ed marketing web taught me

Higher-ed marketing web is a demanding classroom. Accessibility matters. Handoff matters. The people who update the site after launch need a system they can trust—not a clever setup only one developer understands.

• Clear navigation and plain language for mixed audiences
• Accessibility as part of the build, not a late add-on
• Editability and documentation as part of the deliverable
• Judgment: keep it simple unless structure earns its keep

Those habits still shape how I build WordPress sites today.

Accessibility as a daily habit

A college site serves a wide range of people, including people who use screen readers, keyboards, or zoom. I learned to check headings, link text, color contrast, and form labels as I built, not after. The W3C’s WCAG overview became a regular reference.

Building this way from the start is faster than fixing it later. It is also the right thing to do for the people using the site. As a self-taught WordPress developer, I learned accessibility on real pages with real deadlines, which made it stick.

Writing for the next person

In-house work taught me that I would not always be the one making the next change. Someone else might need to update a page on a busy day. So I learned to name things clearly, leave short notes, and keep content editing simple for non-developers. That habit has mattered more than any single skill I picked up as a self-taught WordPress developer.

Power Apps, SharePoint, and missing WordPress

Later I worked with Power Apps and SharePoint for various government agency contractors. I enjoyed that stretch for a while—process-heavy systems, ownership, and workflow thinking. Over time I missed WordPress: public-facing sites, content that marketers can edit, and the open web side of the craft.

That chapter didn’t replace WordPress as the focus. It sharpened how I think about handoff, permissions, and maintainable systems—skills that transfer when a WordPress site has to survive real teams and real turnover.

I wrote more about that change in why I’m moving away from Power Platform and back to modern WordPress, and in coming back to WordPress and why I’m all-in again.

How a self-taught WordPress developer learns

I didn’t wait for a perfect curriculum. I read official docs, verified them on live sites, broke things carefully, fixed them, and asked better questions the next time. Some weeks that meant CSS that finally behaved. Other weeks it meant understanding how a CMS stores content, or why a form failed for the one user who mattered most.

• Read the docs, then confirm against a real site
• Prefer maintainable choices over clever ones
• Treat handoff and editability as part of the work
• Learn through finished projects, not unfinished theory

Official documentation first

When I need to learn something new in WordPress, I start with the source. The WordPress Developer Resources site covers themes, plugins, the REST API, and the Block Editor Handbook. Blog posts and videos help, but I check them against the official docs before I rely on them.

Small projects that ship

Finishing a real project teaches more than reading about one. A recent example is my first plugin in the WordPress.org directory. I wrote about how I published my first WordPress.org plugin, TOCguide, including the review steps and what I had to fix along the way.

Projects like that are how a self-taught WordPress developer fills gaps. You find out what you don’t know when something has to work for other people.

Reading other people’s code

WordPress core, well-built plugins, and good themes are open for anyone to read. When I don’t understand how something works, I open the code and follow it. That has taught me more about hooks, filters, and data handling than any single course. For a self-taught WordPress developer, reading code is one of the most reliable ways to learn.

How I debug problems as a self-taught WordPress developer

When something breaks on a site, my first goal is to understand the problem before I change anything. That habit goes back to my early days with Dreamweaver and ASP, when I had to read each page to see what it was doing. The tools are better now, but the approach is the same.

I start by trying to repeat the problem. If I can make it happen again on purpose, I can usually find the cause. I write down the exact steps, the page, the browser, and what I expected to see. That short note often points me in the right direction before I open any code.

Next, I move the work to my local development site. I don’t want to test guesses on a live site that editors and visitors depend on. Locally, I can turn plugins off one at a time, switch to a default theme, or add logging without anyone noticing.

Browser developer tools answer a lot of questions quickly. I check the console for script errors, look at the network panel to see which requests failed, and inspect the markup to see which styles apply. For PHP problems, I turn on WordPress debug logging and read what it records.

I change one thing at a time. When I change several things at once, I lose track of what actually fixed the problem. Git helps here, because I can see every change I made and roll back anything that did not help.

Once the fix works, I write a short note about what went wrong and why. As a self-taught WordPress developer, I don’t have old class notes to look back on, so these notes are my reference. They save me time when a similar problem comes up again.

Tools I use as a self-taught WordPress developer

My tools have changed a lot since Dreamweaver. The list is simple on purpose. I would rather know a few tools well than chase every new one.

• A code editor. These days I use Cursor, with AI help for routine tasks that I still review line by line.
• Git and GitHub. Every project has version history, so changes can be reviewed and rolled back.
• A local development site. I test changes locally before they go anywhere near a live site.
• Browser developer tools. Most layout and script problems can be found here.
• Accessibility checks. Automated tools catch some issues. I also test with a keyboard and a screen reader.

If you want to see some of that work, I keep a short list in what’s on my GitHub and on this site.

The limits of learning on your own

Being a self-taught WordPress developer has gaps, and I would rather be honest about them. Without a formal program, nobody checks that you covered every topic. You can miss something for a long time because it never came up at work.

I handle that in a few ways. I read the official handbooks end to end when I start a new area, not just the page I need that day. I read code from WordPress core and from plugins I trust. And I take feedback seriously when another developer points out a better way.

That approach is slower than a shortcut, but it has kept my work as a self-taught WordPress developer steady for a long time.

What hiring a self-taught WordPress developer means for your project

Being a self-taught WordPress developer is not a label I use to stand out. It describes how I work. I learned by solving real problems for real teams, so that is still how I approach a project.

• Accessible by default. Headings, labels, contrast, and keyboard use are part of the build.
• Maintainable code. I follow WordPress conventions so another developer can pick up the work.
• Editable content. Editors should be able to update pages without calling me.
• Clear handoff. I document what I built and how to change it.

None of this is unusual for a self-taught WordPress developer who came up through in-house work. It is what I learned the site needs after launch, when the original developer may not be around.

How I work with agencies and shops now

Today I build custom WordPress work for shops and agencies. A lot of that is agency overflow, where a team needs another developer for a project or a busy stretch. I explain how that works in WordPress agency overflow: how white-label help works with me.

I take agency overflow and custom quotes only. I don’t post public pricing, because every project is different and I would rather quote the actual work.

Agencies sometimes ask how a self-taught WordPress developer fits into their process. I’m glad to work inside it: their repository, their coding standards, their review steps, and the tools they already use to communicate.

I also have a full-time job and a freelance side practice, and I’m a dad of twins. That keeps me organized about scope and time. I’m open to agency collaboration, and I’m also open to a full-time role with the right team.

How I keep learning with a busy schedule

I have a full-time job, a freelance WordPress side business, and twins at home. That doesn’t leave long, open blocks of time for study. I had to find a way to keep learning that fits into the time I actually have.

The biggest change was to stop waiting for free time. Instead, I tie learning to the work already in front of me. If a project needs a feature I haven’t built before, I read the documentation for it that week and build it carefully. The project gives the learning a clear purpose and a deadline.

Finally, I try to be realistic. Some weeks, family and my full-time job come first, and I don’t learn anything new. That’s fine. After 17 years of in-house web work, I know that steady progress over time matters more than any single week. For a self-taught WordPress developer, consistency is what keeps skills current.

That same approach is what I would suggest to anyone balancing a job and a family while they learn. Pick one small goal, tie it to real work, and keep going. As a self-taught WordPress developer, I have found that short, regular effort adds up.

Advice if you are learning WordPress on your own

People sometimes ask how to become a self-taught WordPress developer. I can only speak to what worked for me, but these steps held up over the years:

• Build something real, even if it is small, and put it online.
• Read the official handbooks before you search for shortcuts.
• Learn basic HTML, CSS, and PHP well before you add more tools.
• Make accessibility part of every build from the first day.
• Keep notes on what you fix so you can find the answer next time.
• Ask for feedback from people who will use the site.

Progress is slow at first. It speeds up once you have a few finished projects behind you. Every self-taught WordPress developer I know started with small sites that nobody else noticed.

Where I work from

I’m based in Gettysburg, Pennsylvania. If you need a self-taught WordPress developer who learned this work on the job—and who still builds with accessibility and handoff in mind—say hello on /hire/. Tell me what you’re working on; I reply within one business day (ET).

FAQ

Are you formally trained or self-taught?

Primarily self-taught, with deep on-the-job learning. Docs and courses helped; shipping real sites under real constraints taught the rest—starting with that Germanna webmaster role and continuing through higher-ed marketing web.

When did WordPress become the focus?

During the Germanna college site redesign, as we moved from ASP and Contribute toward PHP/WordPress on WP Engine. That’s when WordPress stopped being “another tool” and became the craft I wanted to keep refining.

Why mention Power Apps and SharePoint if WordPress is the focus?

That work with government agency contractors sharpened workflow and ownership thinking. It doesn’t replace WordPress as the specialty—it informs how I hand off maintainable systems.

Can a self-taught WordPress developer handle agency work?

Yes. Agency work depends on clean code, clear communication, and meeting deadlines. I’ve built those habits over years of in-house work, and I follow WordPress coding conventions so an agency team can maintain what I deliver.

Want to work together?

If this background fits your project or team, reach out via /hire/. I’m in Gettysburg, PA, and I reply within one business day (ET).