The dentist search feature on DentalPlans.com includes an interactive Google Map built into a React application. In high-density areas, users experienced jarring flickers and recentering bugs when panning the map, creating a frustrating and unreliable experience.

I replaced the outdated map component with Google’s officially supported implementation, resolving deprecation issues and improving baseline stability. I then introduced memoization to avoid unnecessary re-renders, significantly boosting performance.

The updated solution delivered smoother interactions, reduced redundant API calls, and laid the groundwork for future scalability without additional tech debt.

When I joined DentalPlans.com, the PHP codebase lacked consistency and clarity which made it difficult to develop efficiently. Although PHP_CodeSniffer (phpcs) was technically installed, it wasn’t functioning properly with our editors or surfacing issues in day-to-day development.

I fixed the PHPCS integration with VS Code and ensured our coding standards were correctly recognized and enforced during development. This brought instant visibility to style issues and gave the team real-time feedback loops that naturally reinforced cleaner code without policing.

After 4 months, code quality violations dropped by 70% despite continuous development, with the codebase sitting at 85% improvement 1 year later. This made a significant shift toward long-term maintainability and the team's velocity.

Website deployments at DentalPlans.com used to require 30 minutes of manual prep: developers had to sift through recent Git commits, extract Jira ticket IDs, manually format a list of changes, and send it in an internal release email. The process was slow, error-prone, and often led to inconsistent communication across teams.

I introduced a new workflow using Jira Releases, allowing developers to tag completed tickets as part of a version during normal development. I then automated the remaining steps with a Jira Automation that sends a formatted HTML summary to stakeholders and updates all relevant tickets to their post-release status.

Release prep now takes just 3 minutes, with fewer errors, clearer communication, and full visibility into which features are shipping. The workflow has been so effective that other engineering teams have adopted the same system.

When I joined DentalPlans.com, I audited the frontend’s API usage and uncovered several critical issues: private microservice endpoints and authentication credentials were exposed to the public, and excessive re-rendering in the React app was triggering redundant, uncached requests to a metered third-party API. These problems not only introduced significant security risks but also led to a slow, flickering user experience and unnecessary infrastructure costs.

To address this, I introduced a proxy layer by exposing server-side REST endpoints to securely relay requests. This shielded the frontend from direct access to internal APIs, consolidated authentication logic, and provided a single control point for rate limiting and request shaping.

With object caching and browser-level caching strategies layered on top, the system now handles API traffic more efficiently. Usage costs dropped, performance improved, and the application became more stable—all while eliminating the public exposure of sensitive backend systems.

The Participating Dentist tab on plan details pages provides a feature-rich experience powered by a custom React component and backend API calls. However, usage analytics revealed that most visitors never interacted with this tab, yet the component still mounted eagerly on every page load, triggering unnecessary API activity.

I restructured the rendering logic to opportunistically mount the component only when the tab became visible. This change preserved the interactive experience for engaged users while eliminating invisible overhead for the majority who never opened it.

As a result, the product pages load more efficiently, with a noticeable drop in unnecessary API requests. The change reduced backend load and improved overall performance without sacrificing functionality for users who engaged with the feature.

Accurate location detection is essential to ensure DentalPlans.com displays correct pricing and availability based on a visitor’s geography. During a technical audit, I uncovered race conditions and sequencing flaws in the location lifecycle, leading to unstable behavior and inconsistent plan data which directly eroded user trust.

I refactored the underlying flow by clarifying the business logic and introducing a controlled signaling mechanism. This allowed dependent systems to reliably respond to location changes without redundant polling or fragile conditional checks. A custom event hook replaced ad hoc triggers, simplifying state management across the app.

Since this overhaul, the location system has remained stable without further maintenance. Developers now build on top of it with confidence, accelerating feature delivery instead of reworking brittle edge cases.

Dentist profile pages on DentalPlans.com included a Google Map at the bottom to help users locate practices. After a spike in automated traffic, the site began incurring excessive API usage fees despite most users never scrolling far enough to view the map.

To mitigate this, I implemented a lazy loading strategy that withheld rendering the Google Map until it approached the viewport. This preserved the intended UX while eliminating wasteful load behavior caused by bots and low-engagement users.

As a result, Google Maps API calls dropped significantly, cutting costs without any disruption to the user experience.

Keap is a SaaS CRM, sales, and marketing automation platform that also offers text message marketing. However, it costs over twice as much as using Twilio, the leading API-based cloud communication platform. To keep messaging costs low, I wrote a WordPress plugin to integrate Keap and Twilio.

The primary feature within this plugin is a WordPress admin page for sending an SMS message to a group of Keap contacts. The recipients are determined by chosen Keap tags via a multiselect combobox within the “SMS Blast” form. Below that, there is a text area field to compose the SMS message. Keap contact field variables can be included in the message template with an optional fallback value like %%Contact.FirstName%% or %%Contact.City|your area%%.

Since the goal of this WordPress plugin is to keep marketing costs low, data validation and confirmation are essential. After submitting the SMS Blast form, the system processes and stores the data for review. The review screen shows Keap contacts vs. planned Twilio messages followed by potential alerts of discrepancies. This may include the number of duplicate phone numbers, contacts missing required template variables, and contacts not opted in to receive text messages. Lastly, the review screen offers buttons for sending to a test group and final submission.

This plugin also includes various custom WordPress REST API endpoints to further integrate Twilio and Keap. Some endpoints create, tag, and update Keap contacts while others send texts and trigger flows via Twilio. Within Keap campaigns and Twilio Studio flows, these WordPress endpoints facilitate more engaging and personalized customer experiences.

While Twitter was becoming X and Meta was releasing Threads, Purple Turtle Creative decided to offer a reliable, platform-independent way to keep interested users informed: good ol’ fashioned email. Purple Turtle Creative is a bootstrapped business that keeps costs low by foregoing expensive CRM service subscriptions, though. This meant that I needed to implement a reusable mailing list subscription form by using our API-based email service provider, Mailgun.

Since Mailgun uses volume-based pricing, security was a top priority for the mailing list subscription forms to protect Purple Turtle Creative from exorbitant surprise fees. As the first layer of protection, I implemented Cloudflare’s new CAPTCHA solution called Turnstile on the client side. An advanced bot might still slip through, though, and humans sometimes make mistakes. That’s why I also decided to implement a double opt-in process to ensure the integrity of the mailing list and protect Purple Turtle Creative’s sender reputation.

Using a double opt-in process means that subscribers must click a verification link in a confirmation email to actually subscribe to the mailing list. That costs one email in Mailgun’s volume-based pricing, so I created a database table to track email verification requests and impose rate limits. There is a cooldown period to prevent rapid repeat requests, a maximum number of permitted retries per email address, and a weekly limit of total API usage. Atomic database access is essential to ensure there is consistency between all rate limit trackers and concurrent email verification requests.

To optimize the user experience, the subscription forms submit asynchronously via JavaScript and a custom WordPress REST API endpoint. Form interactions are tracked via Google Analytics on the frontend for conversion performance reporting, and the backend is tracked via Google’s Measurement Protocol API for site reliability monitoring and further insights on system behavior.

“Deal of the Day” (aka DOTD) is a promotional program that features a business’s product across The Houston Chronicle’s websites. The goal of the feature was to inspire urgency for site visitors to claim the deal within a limited timeframe.

Using JavaScript, I built the eye-catching countdown timer component and displayed it throughout notable areas of Chron Shopping. The Chron.com homepage, which receives thousands of site visitors every day, also featured the countdown timer component.

Lastly, I implemented the refreshed design for the Deal of the Day post template. The countdown timer was prominently featured at the top of these pages as well.

After running a successful online business for some time, stale contact records eventually pile up. This means costs consistently increase when using a CRM with volume-based pricing, such as ActiveCampaign. However, there is no quick way to purge these cold contacts within ActiveCampaign!

To help businesses reduce their CRM costs and clean up their records, I created a WordPress plugin. It registers a new WordPress admin page with a quick, multi-step process. Since it is quick to tag contacts within ActiveCampaign in bulk, I decided to mark contacts for deletion with a tag. Then the business can apply the “Marked for Deletion” tag to all ActiveCampaign contact records that they’d like to delete.

In the WordPress admin page, the user first clicks a button to start the process. API requests to ActiveCampaign then retrieve all contact records with the “Marked for Deletion” tag. The WordPress admin page then displays the number of contact records, asking the user to confirm the bulk deletion process. Once confirmed, all contact records are then deleted from ActiveCampaign. Since this process can take a while depending on the number of contacts, I used benchmark tests to also show the WordPress user an estimated end time.

To prepare for the upcoming elections in 2022, Food and Water Action wanted to refresh some areas of their WordPress website. After the web designer and backend developer finished their work, I implemented the frontend styles and interactivity.

The Endorsements page features an interactive SVG map. Different regions of the map become highlighted on hover and, when selected, filter the grid of candidates listed below. The candidate items feature a fun, stylish look with additional hover effects of their own. Fixed at the bottom of the viewport is an interactive donation component that smoothly transforms its layout when expanded. As the user slides between various donation values, the data points dynamically update to inform the donor on the impact of their contribution.

Additionally, I themed the single Endorsement template, the News & Opinions archive template, the Volunteer Stories archive template, and the Victories archive template. Across these templates, I implemented various other frontend features such as masonry grids, sliders, hover animations, animated counters, and scroll effects.

After developing Completionist, I wanted to make it available for free download. Instead of listing it in the WordPress.org plugins directory as I had done with Grouped Content, I wanted to create my own resources server API.

To implement the client-side connection, I used YahnisElsts’s plugin-update-checker package on GitHub. This gave me a fantastic starting place to understand what API endpoints I needed to create.

I packaged the resources server code into a WordPress plugin which runs on Purple Turtle Creative. It includes custom WordPress REST API endpoints to dynamically deliver the plugin’s details from the requested release’s ZIP file.

The endpoints are secured with nonces to ensure the download link expires. Direct requests for the plugin ZIP file are also denied via NGINX rules, so the release package can only be downloaded via a valid request to the resources API. Lastly, I implemented Google Analytics’ Measurement Protocol API to monitor the API’s traffic and performance.

I wanted to track Asana assignments related to my WordPress website as I worked on it. To my amazement, a specialized solution had not been built yet, despite an obvious need in the market.

Ever since then, I have worked on my own solution to integrate Asana tasks with WordPress. Completionist is a WordPress plugin that I offer for free download which features a dashboard widget, post edit panel (aka “metabox”), and custom automations.

Despite being a pretty small project thus far with minimal efforts to make its presence known, Completionist has received some notable attention:

• Original announcement post in the Asana Community Forum received (and continuously receives) a high number of clicks—currently 300+ clicks counted.
• Added to "The ultimate guide for doing things with Asana" integration listing post in the Asana Community Forum, managed by Forum Leader and Asana Partner, Bastien Siebman.
• Featured as the top Asana-to-WordPress integration on WP Forms in their blog post "7 Top Asana Integrations for 2021".

Poor video performance often leads BuddyBoss site owners to use third-party video embeds via YouTube or Vimeo. However, this requires the user to upload and host their videos from another platform—a platform they do not own nor have control over. This is an unacceptable solution for site visitor-uploaded content, which occurs directly on the business’s BuddyBoss WordPress website.

Using the Mux API, I was able to bring video optimizations to WordPress, including normalized audio tracks. I developed a custom WordPress plugin that uploads new videos to Mux and caches the Mux asset data to the site. To ensure the cached asset data is always current, I implemented a custom REST endpoint to process Mux webhook events. The endpoint is secured by verifying each request’s signature.

To achieve a seamless frontend experience, I implemented JavaScript that collects video source URLs that are not hosted via Mux. The video posters are replaced with a “Processing Video” loader gif image while the JavaScript continuously checks each Mux asset’s status. Once the static renditions are ready, the JavaScript sets the video source to the Mux playback URL and removes the “processing” poster.

Beauty Deals Finder is a custom application built with ReactJS + Redux Toolkit and SCSS modules. It is configured and hosted on Houston Chronicle’s local commerce website (aka “Chron Shopping”) via WordPress.

Users may search for deals by selecting various brands and then save their selections as preferences. When a user saves their brand preferences, they are added to an email mailing list in Sailthru to receive automated, personalized daily alerts. The email notifies the user how many new deals have been added for their chosen brands, if any at all, within the past 24 hours. Clicking a link in the email takes the user to the Beauty Deals Finder application, automatically signing them in to review their latest deals.

All deal data displayed in the application and the Sailthru emails is requested from a separate internal service.

The Purple Turtle Creative website was originally created with the Elementor Pro plugin with Elementor’s Hello theme. Since the website no longer needed design changes, it was time to commit the design to custom code. The main goal of the conversion was to remove dependency on the Elementor plugin. This would ultimately optimize site performance, decrease expenses, and reduce upkeep.

Throughout development, Google Lighthouse reports were my main KPIs (key performance indicators). I optimized CSS code coverage by strategically using SCSS partials to compose single stylesheets per theme template. Additionally, I dequeue third-party scripts and stylesheets on templates not using them. My theme scripts use only vanilla JavaScript, so I could remove jQuery as a frontend dependency, as well. To efficiently load the site’s fonts, I limited the imported character sets and defined proper preconnect and preload link tags.

With many other optimizations implemented, the result is a blazing fast, custom Gutenberg WordPress website that loads in less than half a second. For more information, please read my blog post for a thorough report of the performance improvements.

A client of mine had a grand vision for their Black Friday marketing initiatives. They were having a lot of success with Facebook Messenger and used ManyChat to automate conversation flows. For Black Friday, they wanted to give their Facebook contacts an easy way to join their WordPress website.

With their marketing team, I configured a ManyChat flow with Dynamic Blocks to process API requests to their WordPress website. The flow collected various information from the user and then sent a request to a custom WordPress REST API endpoint that I developed. Depending on the information provided, the custom endpoint would register the user in WordPress, tag the user in Keap, reward Gamipress points, and then respond with a success message containing their generated password and a sign-in link.

Upon joining the Local Commerce team at Hearst, I was asked to overhaul our map article custom post type. Each map article post features a custom Google Maps instance with scroll event interactions and animations.

To streamline the curation team’s efforts, I implemented the ability to import their collected merchant listing data from Google Sheets. The data is stored as metadata for each map article post, effectively caching the data in WordPress and serving as the posts’ main content.

With our team’s designer, I then updated the frontend styles and functionality to improve the map articles’ sales appeal. Additional features were implemented to make sponsored listings stand out from the regular listings. In particular, I custom-coded asynchronous email signup form modals which submitted to the Mailchimp and Sailthru APIs. To ensure proper security, I also implemented custom WordPress REST API endpoints to proxy the form submission requests to the third-party APIs. My custom implementation of the Google ReCaptcha v3 API also validated the form submissions to reduce spam signups.

While working full-time as a Software Engineer with Hearst, I took on additional responsibilities by becoming our team’s Sailthru email template engineer. We did not have a very good development process in place to work with Sailthru’s custom templating language (Zephyr), so I also took it upon myself to implement a toolkit.

Since the email templates contain Zephyr markup, I used Sailthru’s API endpoint for previewing Zephyr email templates. That allowed me to edit the templates on my local machine and then render the email in my web browser. For further testing, I could simply tick a checkbox to send a test email of my changes instead.

Additionally, I wrote two other scripts for downloading Sailthru email template contents and "include" template parts respectively. We use Sailthru in advanced ways at Hearst with custom Data Feed configurations, so I architected the toolkit to support that. Synching the template code locally from Sailthru provided a lot of key benefits:

• Version control and code backups via Git (which also facilitates proper code review process)
• Easily make changes to existing email templates using the developer’s own code editor
• Code searchability via terminal commands such as grep (which also means easier code auditing)
• Ability to mix custom code with Sailthru’s WYSIWYG editor to reduce custom code burden
• Detailed template error messaging via the Preview endpoint’s response

PETA Germany had rebranded their Veganstart mobile application and needed to update the promotional website to match. They worked with a web designer to create and publish the layouts in Adobe XD. I then developed a new WordPress Gutenberg theme based on the design compositions.

The site build notably included a custom SlickJS slider, GDPR compliance with CookiePro, custom blocks via ACF Pro’s acf_register_block_type() method in PHP, and adequate accessibility features. The differences between the desktop and mobile styles required quite a bit of finesse to achieve a smooth degradation in screen size. My goal was to use as few markup differences as possible between desktop and mobile to optimize performance and DOM tree simplicity.