Top 10 Newsletter Acquisition Hacks to Double Subscriber Lists in 90 Days for Modern E-commerce Founders and Store Owners
1. Implement a “Content Upgrade” Strategy with Dynamic Offer Generation
Beyond static lead magnets, dynamic content upgrades tied to specific blog posts or product pages offer a higher conversion rate. This involves analyzing user behavior and offering a relevant, high-value download or resource. For e-commerce, this could be a detailed product comparison guide, a styling lookbook for apparel, or a setup/troubleshooting manual for electronics.
The technical implementation requires a robust content management system (CMS) or e-commerce platform capable of conditional logic or a headless CMS with a flexible API. We’ll use a simplified PHP example demonstrating how to serve different upgrades based on the current page’s category or tags.
PHP Example: Dynamic Content Upgrade Logic
<?php
/**
* Dynamically serves a content upgrade based on the current page's context.
* Assumes $currentPageContext is an array or object containing relevant page data
* like 'category', 'tags', 'product_id', etc.
*/
function getDynamicContentUpgrade(array $currentPageContext): ?array {
$upgrade = null;
// Example: If on a specific product page
if (isset($currentPageContext['product_id']) && $currentPageContext['product_id'] === 'XYZ789') {
$upgrade = [
'title' => 'Exclusive Setup Guide for XYZ789',
'description' => 'Master your new XYZ789 with our step-by-step guide.',
'download_url' => '/downloads/xyz789-setup-guide.pdf',
'cta_text' => 'Get the Setup Guide'
];
}
// Example: If on a blog post in the 'fashion' category
elseif (isset($currentPageContext['category']) && $currentPageContext['category'] === 'fashion') {
// Further check for specific tags if needed
if (in_array('summer-trends', $currentPageContext['tags'] ?? [])) {
$upgrade = [
'title' => '2024 Summer Fashion Lookbook',
'description' => 'Discover the hottest trends for this season.',
'download_url' => '/downloads/summer-fashion-lookbook-2024.pdf',
'cta_text' => 'Download Lookbook'
];
} else {
$upgrade = [
'title' => 'Wardrobe Essentials Checklist',
'description' => 'Ensure your closet is ready for any occasion.',
'download_url' => '/downloads/wardrobe-essentials.pdf',
'cta_text' => 'Get the Checklist'
];
}
}
// Default upgrade if no specific context matches
else {
$upgrade = [
'title' => 'Your First Purchase Discount',
'description' => 'Sign up and get 15% off your first order!',
'download_url' => '#', // This might trigger a signup form directly
'cta_text' => 'Claim My Discount'
];
}
return $upgrade;
}
// --- Usage Example (within your page rendering logic) ---
// Assume $pageData is populated from your CMS/database
// $pageData = ['category' => 'fashion', 'tags' => ['summer-trends'], 'product_id' => null];
// $contentUpgrade = getDynamicContentUpgrade($pageData);
// if ($contentUpgrade) {
// echo "<div class='content-upgrade-box'>";
// echo "<h4>" . htmlspecialchars($contentUpgrade['title']) . "</h4>";
// echo "<p>" . htmlspecialchars($contentUpgrade['description']) . "</p>";
// echo "<a href='" . htmlspecialchars($contentUpgrade['download_url']) . "' class='btn btn-primary'>" . htmlspecialchars($contentUpgrade['cta_text']) . "</a>";
// echo "</div>";
// }
?>
This PHP function `getDynamicContentUpgrade` would be integrated into your theme’s template files or a custom plugin. The `$currentPageContext` array needs to be populated with data relevant to the current page being viewed. This data can be extracted from URL parameters, database queries, or CMS metadata.
2. Implement Exit-Intent Popups with Advanced Segmentation
Exit-intent popups are a classic, but their effectiveness hinges on intelligent segmentation. Instead of a generic popup for all visitors, tailor the offer based on their browsing history, cart contents, or referral source. For instance, a user who has viewed a specific product category multiple times but hasn’t purchased might be offered a discount on that category. A user abandoning a cart with high-value items could receive a free shipping offer.
Technically, this involves JavaScript for detecting exit intent and sending data to a backend service or directly to your email marketing platform’s API for segmentation and offer delivery. We’ll outline a conceptual JavaScript approach that could integrate with services like Mailchimp, Klaviyo, or a custom solution.
JavaScript Example: Exit Intent Detection and Data Capture
document.addEventListener('DOMContentLoaded', function() {
let hasExited = false;
const exitIntentThreshold = 100; // Pixels from top of viewport to trigger
document.addEventListener('mouseout', function(e) {
// Check if the mouse is moving upwards towards the top of the viewport
// and if the user hasn't already triggered the intent
if (!hasExited && e.clientY < exitIntentThreshold) {
hasExited = true;
captureUserDataAndTriggerPopup();
}
});
// Fallback for mobile devices (less reliable, often requires a different trigger like scroll depth)
// For mobile, consider a timed popup or scroll-depth trigger instead of mouseout.
// This example focuses on desktop exit intent.
function captureUserDataAndTriggerPopup() {
// 1. Capture user data (requires access to DOM or analytics data)
const userData = {
pageUrl: window.location.href,
referrer: document.referrer,
cartValue: getCartValue(), // Function to get cart total from session/cookie/API
viewedCategories: getViewedCategories(), // Function to get categories user has browsed
// Add other relevant data points
};
// 2. Send data to backend or directly to ESP API (e.g., Klaviyo, Mailchimp)
// This is a simplified example; actual implementation would involve API calls.
console.log('Exit intent detected. User data:', userData);
// Example: Triggering a modal popup (using a hypothetical library or custom code)
// triggerModalPopup(userData);
// Example: Sending data to an ESP API (e.g., Klaviyo)
// sendToKlaviyo(userData);
}
// --- Placeholder functions ---
function getCartValue() {
// Implement logic to retrieve cart total (e.g., from localStorage, cookies, or an API call)
// Example: return parseFloat(localStorage.getItem('cartTotal')) || 0;
return 150.75; // Dummy value
}
function getViewedCategories() {
// Implement logic to track viewed categories (e.g., using session storage or data attributes)
// Example: return JSON.parse(sessionStorage.getItem('viewedCategories')) || [];
return ['electronics', 'audio']; // Dummy value
}
// Hypothetical function to trigger a modal
// function triggerModalPopup(data) {
// // Logic to display a popup, potentially with dynamic content based on 'data'
// const popupElement = document.getElementById('exit-intent-popup');
// if (popupElement) {
// // Populate popup content based on data
// popupElement.style.display = 'block';
// }
// }
// Hypothetical function to send data to an ESP
// function sendToKlaviyo(data) {
// // Use Klaviyo's JS SDK or direct API calls
// // Example:
// // if (typeof _learnq !== 'undefined') {
// // _learnq.push(['track', 'Exit Intent', data]);
// // }
// }
});
The `captureUserDataAndTriggerPopup` function is the core. It gathers contextual information about the user’s session. This data is crucial for the segmentation logic that determines which offer to present. The actual popup display and offer logic would typically be handled by a dedicated JavaScript library (like OptinMonster, Privy, or custom-built) or by directly interacting with your Email Service Provider’s (ESP) JavaScript SDK.
3. Leverage User-Generated Content (UGC) in Acquisition Flows
Authenticity drives conversions. Integrating UGC, such as customer reviews, testimonials, and social media posts featuring your products, into your acquisition funnels can significantly boost trust and sign-up rates. This isn’t just about displaying reviews on product pages; it’s about actively using them in popups, on landing pages, and even in email sequences.
The technical challenge lies in efficiently collecting, moderating, and displaying UGC. For acquisition, we can use UGC snippets within signup forms or as social proof elements on lead generation pages. Consider using a service like Yotpo, Trustpilot, or Bazaarvoice, or build a custom solution using social media APIs and a database.
Example: Displaying a Random Testimonial in a Signup Form
document.addEventListener('DOMContentLoaded', function() {
const testimonials = [
{
quote: "Absolutely love the quality! My new [Product Name] is fantastic.",
author: "Jane D."
},
{
quote: "Fast shipping and excellent customer service. Highly recommend!",
author: "Mark S."
},
{
quote: "This [Product Category] has transformed my daily routine. Worth every penny.",
author: "Emily R."
}
// Add more testimonials
];
const signupFormContainer = document.getElementById('signup-form-container'); // Assume this is where your form is
if (signupFormContainer && testimonials.length > 0) {
// Select a random testimonial
const randomIndex = Math.floor(Math.random() * testimonials.length);
const selectedTestimonial = testimonials[randomIndex];
// Create and insert the testimonial element
const testimonialElement = document.createElement('div');
testimonialElement.className = 'ugc-testimonial-snippet';
testimonialElement.innerHTML = `
<p class="quote">“${selectedTestimonial.quote}”</p>
<p class="author">- ${selectedTestimonial.author}</p>
`;
// Insert before the form or at a strategic position
signupFormContainer.insertBefore(testimonialElement, signupFormContainer.firstChild);
}
});
This JavaScript snippet randomly selects a testimonial from a predefined array and injects it into the DOM near your signup form. In a production environment, the `testimonials` array would likely be fetched dynamically from a backend API or a UGC platform, allowing for real-time updates and better management. Ensure your CSS styles `.ugc-testimonial-snippet` appropriately to integrate seamlessly with your form’s design.
4. Implement a “Refer-a-Friend” Program with Tiered Rewards
Word-of-mouth marketing is incredibly powerful. A well-structured refer-a-friend program incentivizes existing customers to bring in new ones. The key to doubling lists is to make the rewards compelling and tiered. For example, refer 1 friend, get 10% off; refer 3 friends, get 25% off and free shipping; refer 5 friends, get a free product.
Technically, this requires a system to track unique referral links, validate referred signups/purchases, and distribute rewards. This can be built custom or integrated with third-party referral marketing platforms (e.g., ReferralCandy, Friendbuy). A custom implementation often involves generating unique tokens for each user and a backend service to validate them.
Database Schema Snippet (Conceptual SQL)
-- Table to store referral codes and associated user IDs
CREATE TABLE referral_codes (
id INT AUTO_INCREMENT PRIMARY KEY,
user_id INT NOT NULL,
referral_code VARCHAR(50) UNIQUE NOT NULL,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
);
-- Table to track successful referrals
CREATE TABLE referrals (
id INT AUTO_INCREMENT PRIMARY KEY,
referrer_user_id INT NOT NULL,
referred_user_id INT NULL, -- NULL until the referred user signs up/completes action
referral_code_used VARCHAR(50) NOT NULL,
status ENUM('pending', 'completed', 'invalid') DEFAULT 'pending',
referred_at TIMESTAMP NULL,
completed_at TIMESTAMP NULL,
reward_issued BOOLEAN DEFAULT FALSE,
FOREIGN KEY (referrer_user_id) REFERENCES users(id) ON DELETE CASCADE,
FOREIGN KEY (referral_code_used) REFERENCES referral_codes(referral_code)
);
-- Table to store reward tiers and conditions
CREATE TABLE reward_tiers (
id INT AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(100) NOT NULL,
required_successful_referrals INT NOT NULL,
reward_type VARCHAR(50) NOT NULL, -- e.g., 'discount_percentage', 'free_shipping', 'free_product'
reward_value VARCHAR(100) NOT NULL, -- e.g., '25' for percentage, 'true' for shipping, 'product_sku'
description TEXT
);
The backend logic would involve: 1. Generating a unique `referral_code` for each new user in `referral_codes`. 2. When a new user signs up using a referral code, create an entry in the `referrals` table, linking the `referrer_user_id` and the `referred_user_id`. 3. Periodically check the `referrals` table to count successful referrals for each user and match them against `reward_tiers` to issue rewards.
5. Optimize Landing Pages for Specific Traffic Sources
Generic landing pages rarely achieve high conversion rates. For rapid list growth, create highly targeted landing pages for each significant traffic source (e.g., Facebook Ads, Google Ads, specific influencer campaigns, organic search terms). The messaging, offer, and design should directly address the intent of the visitor arriving from that source.
This requires a flexible landing page builder or a CMS that allows for easy creation and A/B testing of multiple page variations. Server-side rendering (SSR) or dynamic content injection can personalize the landing page further based on URL parameters passed from ad campaigns.
Example: Dynamic Headline based on UTM Parameters (PHP/Server-Side)
<?php
// Assume this is part of your landing page template file
function getDynamicHeadline(string $defaultHeadline): string {
$headline = $defaultHeadline;
// Check for specific UTM parameters
if (isset($_GET['utm_source'])) {
switch (strtolower($_GET['utm_source'])) {
case 'facebook':
if (isset($_GET['utm_campaign']) && strpos(strtolower($_GET['utm_campaign']), 'summer_sale') !== false) {
$headline = "Unlock 50% Off Our Summer Collection!";
} else {
$headline = "Discover Top Fashion Picks on Facebook!";
}
break;
case 'google':
if (isset($_GET['utm_term']) && strpos(strtolower($_GET['utm_term']), 'best running shoes') !== false) {
$headline = "Find Your Perfect Pair of Running Shoes";
} else {
$headline = "Shop High-Quality Electronics Online";
}
break;
case 'influencer_xyz':
$headline = "Exclusive Offer from Influencer XYZ Just For You!";
break;
// Add more cases for other sources
}
}
return htmlspecialchars($headline);
}
$defaultHeadline = "Join Our Community & Get Exclusive Deals";
?>
<!-- In your HTML -->
<h1><?= getDynamicHeadline($defaultHeadline) ?></h1>
This PHP code snippet checks for `utm_source` and `utm_content` (or `utm_term`, `utm_campaign`) URL parameters. Based on these parameters, it dynamically adjusts the landing page’s main headline. This ensures that visitors arriving from different campaigns see a message that resonates directly with their entry point, increasing relevance and conversion probability. Ensure your ad campaigns are meticulously tagged with UTM parameters.
6. Implement a “Content Locker” for High-Value Resources
Content lockers are overlays that block access to content until the user performs an action, typically signing up for a newsletter. For maximum impact, use this for truly high-value content: in-depth guides, exclusive webinars, premium templates, or early access to product drops. The perceived value must justify the “cost” of an email address.
Technically, this involves JavaScript to detect when a user tries to access the locked content and then displaying an overlay. The overlay contains the signup form. Once the user signs up, the overlay is removed, and the content is revealed. Services like Viral Loops or custom implementations can achieve this.
JavaScript Example: Basic Content Locker Implementation
document.addEventListener('DOMContentLoaded', function() {
const lockedContentSelector = '.locked-content'; // Selector for the content that is initially hidden
const lockerOverlaySelector = '#content-locker-overlay';
const signupFormSelector = '#locker-signup-form'; // The form within the overlay
const lockedContent = document.querySelector(lockedContentSelector);
const lockerOverlay = document.querySelector(lockerOverlaySelector);
if (lockedContent && lockerOverlay) {
// Check if user has already unlocked this content (e.g., via cookie or session)
if (!hasUserUnlockedContent()) {
// Hide the actual content initially
lockedContent.style.display = 'none';
// Show the locker overlay
lockerOverlay.style.display = 'flex'; // Or 'block', depending on CSS
// Handle form submission
const signupForm = document.querySelector(signupFormSelector);
if (signupForm) {
signupForm.addEventListener('submit', function(event) {
event.preventDefault(); // Prevent default form submission
const emailInput = signupForm.querySelector('input[type="email"]');
const userEmail = emailInput.value.trim();
if (userEmail && isValidEmail(userEmail)) {
// Send email to your backend/ESP API
sendEmailForUnlock(userEmail, function(success) {
if (success) {
// Mark user as unlocked (e.g., set a cookie)
markUserAsUnlocked();
// Hide the overlay
lockerOverlay.style.display = 'none';
// Reveal the content
lockedContent.style.display = 'block';
// Optionally, clear the form
emailInput.value = '';
} else {
alert('An error occurred. Please try again.');
}
});
} else {
alert('Please enter a valid email address.');
}
});
}
} else {
// User has already unlocked, ensure content is visible
lockedContent.style.display = 'block';
lockerOverlay.style.display = 'none';
}
}
// --- Helper Functions ---
function hasUserUnlockedContent() {
// Check for a cookie, localStorage item, or session variable
// Example: return localStorage.getItem('unlocked_resource_xyz') === 'true';
return false; // Default to false for demonstration
}
function markUserAsUnlocked() {
// Set a cookie or localStorage item to remember the user
// Example: localStorage.setItem('unlocked_resource_xyz', 'true');
// Set an expiration for the cookie/localStorage if needed
}
function isValidEmail(email) {
// Basic email validation regex
const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
return emailRegex.test(email);
}
function sendEmailForUnlock(email, callback) {
// This function would make an AJAX call to your server or ESP API
// Example using fetch API:
fetch('/api/unlock-resource', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ email: email })
})
.then(response => response.json())
.then(data => {
if (data.success) {
callback(true);
} else {
callback(false);
}
})
.catch(error => {
console.error('Error sending email:', error);
callback(false);
});
}
});
The `locked-content` element is hidden, and the `content-locker-overlay` is shown. The JavaScript listens for the form submission within the overlay. Upon successful submission (after sending the email to your backend/ESP), it sets a flag (e.g., in `localStorage`) to remember the user, hides the overlay, and reveals the content. The `sendEmailForUnlock` function is a placeholder for your actual API call.
7. Implement Interactive Quizzes and Calculators
Interactive tools like quizzes (“Which [Product Type] is Right for You?”) or calculators (“How Much Can You Save With Our Service?”) are highly engaging. They provide immediate value to the user and naturally lead to an email signup to receive the results or a personalized recommendation.
Technically, this involves front-end JavaScript for the interactive logic and a backend to store results or trigger personalized emails. The key is to make the quiz/calculator relevant to your products and the user’s potential needs.
JavaScript Example: Simple Product Recommendation Quiz
document.addEventListener('DOMContentLoaded', function() {
const quizSteps = [
{ question: "What's your primary use case?", options: ["Home", "Office", "Travel"] },
{ question: "What's your budget range?", options: ["$", "$$", "$$$"] },
{ question: "What feature is most important?", options: ["Durability", "Portability", "Performance"] }
];
let currentStep = 0;
let userAnswers = {};
const quizContainer = document.getElementById('product-quiz');
const questionElement = document.getElementById('quiz-question');
const optionsElement = document.getElementById('quiz-options');
const resultsElement = document.getElementById('quiz-results');
const emailFormElement = document.getElementById('quiz-email-form');
function renderStep() {
if (currentStep < quizSteps.length) {
questionElement.textContent = quizSteps[currentStep].question;
optionsElement.innerHTML = ''; // Clear previous options
quizSteps[currentStep].options.forEach(option => {
const button = document.createElement('button');
button.textContent = option;
button.className = 'quiz-option-btn';
button.onclick = () => selectOption(option);
optionsElement.appendChild(button);
});
} else {
// End of quiz, show results
showResults();
}
}
function selectOption(option) {
userAnswers[`step_${currentStep}`] = option;
currentStep++;
renderStep();
}
function showResults() {
quizContainer.style.display = 'none';
resultsElement.style.display = 'block';
emailFormElement.style.display = 'block'; // Show email form to get results
// --- Logic to determine recommendation based on userAnswers ---
let recommendation = "Our Standard Model"; // Default
if (userAnswers['step_0'] === "Travel" && userAnswers['step_2'] === "Portability") {
recommendation = "The Ultra-Light Travel Edition";
} else if (userAnswers['step_1'] === "$$$" && userAnswers['step_2'] === "Performance") {
recommendation = "The Pro Performance Series";
}
// ... more complex logic ...
document.getElementById('recommendation-text').textContent = recommendation;
// You would also send userAnswers to a backend to generate a more detailed report/email.
}
// Handle email form submission to send results
emailFormElement.addEventListener('submit', function(event) {
event.preventDefault();
const email = document.getElementById('quiz-email-input').value.trim();
if (email && isValidEmail(email)) {
// Send email and userAnswers to backend
sendQuizResults(email, userAnswers, document.getElementById('recommendation-text').textContent);
alert('Your personalized recommendation has been sent to your email!');
emailFormElement.style.display = 'none'; // Hide form after submission
} else {
alert('Please enter a valid email.');
}
});
// Initial render
renderStep();
});
// Assume isValidEmail and sendQuizResults functions are defined elsewhere (similar to content locker example)
The `renderStep` function displays the current question and its options. `selectOption` records the answer and moves to the next step. Once all questions are answered, `showResults` determines a product recommendation based on `userAnswers` and prompts the user to enter their email to receive the detailed results. The `sendQuizResults` function would handle sending this data to your backend for personalized email generation.
8. Implement a “Spin the Wheel” Gamification Mechanic
Gamification significantly increases engagement. A “spin the wheel” popup offers a chance to win discounts, free shipping, or small products. This creates excitement and a sense of urgency, often leading to higher conversion rates for email signups compared to static offers.
Technically, this requires front-end JavaScript to create the spinning animation and manage the prize logic. You’ll need to define prize probabilities and ensure that the prize awarded is tracked and redeemable. Integration with your email platform is crucial for sending discount codes.
JavaScript Example: Spin the Wheel Logic
document.addEventListener('DOMContentLoaded', function() {
const wheel = document.querySelector('.wheel');
const spinButton = document.getElementById('spin-button');
const prizeDisplay = document.getElementById('prize-display');
const emailForm = document.getElementById('wheel-email-form');
const overlay = document.getElementById('wheel-overlay');
// Define prizes and their probabilities (sum should be 100)
const prizes = [
{ name: "10% Off", probability: 40 },
{ name: "Free Shipping", probability: 30 },
{ name: "20% Off", probability: 15 },
{ name: "Free Product (Small Item)", probability: 10 },
{ name: "Try Again!", probability: 5 }
];
let isSpinning = false;
let selectedPrize = null;
spinButton.addEventListener('click', () => {
if (isSpinning) return;
isSpinning = true;
spinButton.disabled = true;
prizeDisplay.textContent = "Spinning...";
// Calculate a random prize based on probabilities
selectedPrize = getRandomPrize();
// Animate the wheel spin (simplified example)
// In a real implementation, use CSS transitions/animations or a library like GSAP
const spinDuration = 5000; // 5 seconds
const spinDegrees = 360 * 5 + Math.random() * 360; // Spin multiple times + random offset
wheel.style.transition = `transform ${spinDuration / 1000}s ease-out`;
wheel.style.transform = `rotate(${spinDegrees}deg)`;
setTimeout(() => {
isSpinning = false;
wheel.style.transition = 'none'; // Reset transition for next spin
// Position the wheel to show the selected prize (this requires careful calculation based on prize segments)
// For simplicity, we'll just display the prize name.
prizeDisplay.textContent = `You won: ${selectedPrize.name}!`;
if (selectedPrize.name !== "Try Again!") {
emailForm.style.display = 'block'; // Show form to claim prize
} else {
spinButton.disabled = false; // Allow another spin if "Try Again!"
}
}, spinDuration);
});
emailForm.addEventListener('submit', function(event) {
event.preventDefault();
const email = document.getElementById('wheel-email-input').value.trim();
if (email && isValidEmail(email)) {
// Send email and prize details to backend
claimWheelPrize(email, selectedPrize);
alert('Your prize details have been sent to your email!');
overlay.style.display = 'none'; // Close overlay
} else {
alert('Please enter a valid email.');
}
});
function getRandomPrize() {
const randomNum = Math.random() * 100;
let cumulativeProbability = 0;
for (const prize of prizes) {
cumulativeProbability += prize.probability;
if (randomNum < cumulativeProbability) {
return prize;
}
}
// Fallback (should not happen if probabilities sum to 100)
return prizes[prizes.length - 1];
}
// Placeholder functions
function isValidEmail(email) { /* ... */ return true; }
function claimWheelPrize(email, prize) {
console.log(`Claiming prize: ${prize.name} for email: ${email}`);
// Implement API call to your backend/ESP
}
});
The `getRandomPrize` function uses a weighted random selection based on probabilities. The animation is a simplified `setTimeout` with CSS transform. In a production system, you’d use a dedicated animation library and ensure the wheel visually stops on the correct segment. The email form is shown only if a valid prize is won, prompting the user to claim it.
9. Implement a “Welcome Mat” or Full-Screen Interstitial
A full-screen welcome mat or interstitial, displayed immediately upon a visitor’s first arrival, can be highly effective for capturing attention and email addresses. It’s more intrusive than a popup but can yield higher conversion rates if the offer is compelling and the design is clean.
Technically, this involves JavaScript to detect first-time visitors (usually via a cookie) and display a full-screen overlay. The overlay contains your signup offer. It should be easily dismissible and designed to be visually appealing on all devices.
JavaScript Example: First-Time Visitor Welcome Mat
document.addEventListener('DOMContentLoaded', function() {
const WELCOME_COOKIE_NAME = 'has_seen_welcome_mat';
const cookieExpiryDays = 30; // Show again after 30 days if they didn't subscribe
function setCookie(name, value, days) {
let expires = "";
if (days) {
const date = new Date();
date.setTime(date.getTime() + (days * 24 * 60 * 60 * 1000));
expires = "; expires=" + date.toUTCString();
}
document.cookie = name + "=" + (value || "") + expires + "; path=/";
}