Strikingly Troubleshooting Overview

Troubleshoot common Strikingly issues including performance problems and tracking failures.

Common issues you may encounter with your Strikingly site and how to diagnose and fix them.

Performance Issues

Strikingly sites are generally optimized for speed, but custom code and third-party integrations can impact performance. Core Web Vitals affect both user experience and SEO rankings.

Largest Contentful Paint (LCP)

LCP measures loading performance. Strikingly-specific LCP issues include:

Hero images not optimized for Strikingly's image system
Custom code blocking render in header
Third-party scripts loading synchronously
Heavy JavaScript in custom HTML sections
Multiple tracking pixels without GTM

Target: LCP under 2.5 seconds

Cumulative Layout Shift (CLS)

CLS measures visual stability. Strikingly-specific CLS issues include:

Images without explicit dimensions in custom sections
Dynamic content from third-party widgets
Custom fonts loading without font-display
Embedded social media widgets
Custom HTML sections shifting layout

Target: CLS under 0.1

General Performance Best Practices

Template Selection:

Use modern Strikingly templates
Avoid heavily customized old templates
Test template performance before committing
Consider mobile-first templates

Custom Code Management:

Minimize custom JavaScript
Use async/defer for all external scripts
Consolidate tracking through GTM
Remove unused custom code sections
Test code impact on performance

Image Optimization:

Use Strikingly's built-in image uploads (auto-optimized)
Compress images before uploading
Use appropriate image formats (WebP when possible)
Avoid extremely large hero images (> 500KB)
Set image quality settings appropriately

Third-Party Scripts:

Use GTM to manage all tracking codes
Delay non-critical scripts
Remove unused integrations
Monitor script impact on load time

For general performance concepts, see the global performance hub.

Tracking & Analytics Issues

Events Not Firing

Common causes of tracking failures on Strikingly:

Custom code not saved or site not published
JavaScript errors in custom code
Ad blockers preventing pixel loads
Incorrect GTM container configuration
Missing or incorrect tracking IDs
Code placement issues (header vs. footer)

Common scenarios:

GA4 not showing real-time data (installation issue)
Meta Pixel shows errors in Pixel Helper (code error)
GTM tags not firing (trigger configuration)
Events firing multiple times (duplicate code)

Tracking Best Practices

Consolidate Through GTM:

Install GTM once in header code
Add all tracking pixels through GTM
Easier to manage and update
Better performance
Test changes before publishing

Test Thoroughly:

Use browser extensions (GTM debugger, Meta Pixel Helper)
Test in incognito/private browsing
Test across different browsers
Test on mobile devices
Verify in platform analytics (GA4, Meta Events Manager)
Use debug modes when available

Monitor Continuously:

Check analytics platforms weekly
Set up custom alerts for tracking failures
Monitor data quality and accuracy
Review conversion tracking regularly

For general tracking concepts, see the global tracking hub.

Common Strikingly-Specific Issues

Custom Code Not Working

Problem: Code added to Strikingly settings doesn't execute.

Common Causes:

Code not saved in settings
Site not republished after adding code
JavaScript syntax errors
Code added to wrong location (footer vs header)
Conflicts with existing code

Diagnosis:

Open browser console (F12)
Look for JavaScript errors
Check if code is present in page source
Verify code location in Strikingly settings

Fix:

Ensure you clicked Save in Custom Code settings
Publish site after making changes
Fix JavaScript syntax errors
Move code to header if in footer (or vice versa)
Wrap code in DOMContentLoaded event listener

Free Plan Limitations

Problem: Cannot add tracking code.

Limitation: Strikingly Free plan doesn't allow custom code injection.

Workaround: None - must upgrade to Limited, Pro, or VIP plan.

Solution:

Upgrade to paid plan for custom code access
Minimum: Limited plan for basic tracking
Recommended: Pro plan for full features

One-Page Site Tracking Issues

Problem: Only homepage appears in analytics.

Expected Behavior: Strikingly specializes in one-page sites.

Solution: Implement section tracking instead of page views:

// Track section views as virtual page views
document.addEventListener('DOMContentLoaded', function() {
  var sections = document.querySelectorAll('section');
  var tracked = new Set();

  var observer = new IntersectionObserver(function(entries) {
    entries.forEach(function(entry) {
      if (entry.isIntersecting && !tracked.has(entry.target.id)) {
        tracked.add(entry.target.id);

        // For GA4
        gtag('event', 'page_view', {
          page_title: entry.target.id,
          page_location: window.location.href + '#' + entry.target.id
        });

        // For Meta Pixel
        fbq('track', 'ViewContent', {
          content_name: entry.target.id
        });
      }
    });
  }, { threshold: 0.5 });

  sections.forEach(function(s) { observer.observe(s); });
});

Site Builder Limitations

Problem: Cannot access certain areas for tracking code.

Strikingly Limitations:

No direct theme file access
Limited to header/footer code injection
Cannot modify core template files
No server-side code execution
Limited e-commerce tracking capabilities

Workarounds:

Use custom HTML sections for page-specific code
Implement client-side tracking only
Use GTM for complex tag management
Work within custom code constraints

Form Tracking Issues

Problem: Contact form submissions not tracked.

Cause: Strikingly forms submit without page reload or clear success indicator.

Solution: Track form submission via event listener:

document.addEventListener('DOMContentLoaded', function() {
  var forms = document.querySelectorAll('form, .s-contact-form');

  forms.forEach(function(form) {
    form.addEventListener('submit', function() {
      // Track with GA4
      gtag('event', 'form_submit', {
        form_name: 'contact_form'
      });

      // Track with Meta Pixel
      fbq('track', 'Lead');
    });
  });

  // Also watch for success message
  var observer = new MutationObserver(function(mutations) {
    mutations.forEach(function(mutation) {
      mutation.addedNodes.forEach(function(node) {
        if (node.classList && node.classList.contains('s-form-success')) {
          gtag('event', 'form_success');
          fbq('track', 'CompleteRegistration');
        }
      });
    });
  });

  observer.observe(document.body, { childList: true, subtree: true });
});

Mobile vs Desktop Tracking Discrepancies

Problem: Different tracking behavior on mobile vs desktop.

Causes:

Mobile browsers handle scripts differently
Touch events vs mouse events
Mobile ad blockers more aggressive
iOS tracking restrictions (ITP)

Solutions:

Test thoroughly on mobile devices
Use touch events in addition to click events
Implement Server-Side Tracking (Conversions API)
Use Google Consent Mode for iOS compliance

Debugging Tools

Browser Developer Tools

Chrome DevTools (F12):

Console: Check for JavaScript errors
Network: Verify tracking requests sent
Application: Check localStorage, cookies
Sources: Debug custom JavaScript

Common Console Checks:

// Check if GA4 loaded
typeof gtag !== 'undefined'

// Check if Meta Pixel loaded
typeof fbq !== 'undefined'

// Check GTM data layer
console.log(dataLayer)

// View all tracking requests
// Filter Network tab by: "collect", "fbevents", "gtm"

Strikingly-Specific Tools

View Custom Code:

Right-click on your site
View Page Source (Ctrl+U)
Search (Ctrl+F) for your tracking IDs
Verify code is present and correct

Test Custom Code:

// Add to console to test code snippets
(function() {
  // Your custom code here
})();

Analytics Debugging Tools

Browser Extensions:

Platform Tools:

GA4 DebugView (Admin → DebugView)
Meta Events Manager Test Events
GTM Preview Mode

Performance Testing Tools

Google PageSpeed Insights
WebPageTest
GTmetrix
Chrome DevTools Lighthouse

Strikingly Performance Check:

Run PageSpeed Insights on your site
Note Core Web Vitals scores
Check "Opportunities" section
Identify custom code impact

Getting Help

Strikingly Support Channels

Strikingly Help Center:

support.strikingly.com
Comprehensive knowledge base
Step-by-step guides

Strikingly Support:

Email support for all paid plans
Live chat for Pro/VIP plans
Response typically within 24 hours

Strikingly Community:

User forums
Share experiences
Get community help

Third-Party Platform Support

For Tracking Issues:

When to Hire a Developer

Consider hiring help when:

Complex custom functionality needed
Multiple tracking integrations conflicting
Advanced e-commerce tracking required
Performance issues persist despite optimizations
Custom integrations beyond standard tracking
Server-side tracking implementation needed

Finding Developers:

Upwork, Fiverr for freelancers
Strikingly Partner Network
Web analytics specialists
Tag management consultants

Prevention Best Practices

Documentation

Document Your Setup:

List all tracking codes installed
Note GTM tags and triggers
Record custom code additions
Keep tracking ID reference
Document any custom events

Testing Workflow

Before Adding Code:

Test code in isolated environment
Check for JavaScript errors
Verify syntax is correct
Ensure no conflicts with existing code

After Adding Code:

Save settings in Strikingly
Publish site
Test in real-time (GA4, Meta, etc.)
Check browser console
Verify with debugging tools
Test on mobile device

Monitoring Routine

Weekly:

Check analytics platforms for data
Verify conversion tracking accuracy
Review error logs if available

Monthly:

Audit installed tracking codes
Remove unused integrations
Review performance metrics
Update documentation

Quarterly:

Full tracking audit
Performance optimization review
Update tracking implementations
Test all conversion paths

Common Error Messages

"gtag is not defined"

Cause: GA4 code not loaded or syntax error.

Fix:

Verify GA4 code is in Header Code
Check Measurement ID is correct
Ensure site was published
Check for JavaScript errors blocking load

"fbq is not defined"

Cause: Meta Pixel code not loaded.

Fix:

Verify pixel code is in Header Code
Check Pixel ID is correct
Ensure site was published
Test without ad blockers

"dataLayer is not defined"

Cause: GTM container not loaded.

Fix:

Verify GTM code is in Header Code
Check Container ID (GTM-XXXXXX)
Ensure site was published
Check for errors blocking GTM

Permission Denied / CORS Error

Cause: Trying to access external resources blocked by browser.

Fix:

Use proper async loading for scripts
Ensure proper CORS headers
May need to use GTM instead of direct embedding

Next Steps

Performance Issues:

Tracking Issues:

Debug Events Not Firing

Prevention:

Document your setup
Test before and after changes
Monitor regularly
Keep tracking codes updated

For general troubleshooting concepts, see the global issues hub.