
<div class="vce-row-container">
<div id="el-c7b559e9" class="vce-row vce-row--col-gap-30 vce-row-columns--top vce-row-content--top" data-vce-do-apply="all el-c7b559e9">
<div class="vce-row-content" data-vce-element-content="true">
<div id="el-fb27ab94" class="vce-col vce-col--md-100p vce-col--xs-1 vce-col--xs-last vce-col--xs-first vce-col--sm-last vce-col--sm-first vce-col--md-last vce-col--lg-last vce-col--xl-last vce-col--md-first vce-col--lg-first vce-col--xl-first" data-vce-do-apply="background border el-fb27ab94">
<div class="vce-col-inner" data-vce-element-content="true" data-vce-do-apply="padding margin el-fb27ab94">
<div class="vce-text-block">
<div id="el-74dd3309" class="vce-text-block-wrapper vce" data-vce-do-apply="all el-74dd3309">

Here’s an interesting question that is sure to inspire a spirited debate between programmers. Which has more promotional value: Giving away valuable prizes by spreading them across several days (or weeks) and dayparts or isolating a short period of time for one day contests.

<em>This article explores a strategy of focusing more attention on shorter time periods. Including:</em>
<ul>
 	<li><em>Why focusing giveaways on a shorter time period works better than spreading them out.</em></li>
 	<li><em>The power of building a promotional special event.</em></li>
 	<li><em>Ratings proof from stations that have implemented this strategy.</em></li>
</ul>
<h2>One Day Contests</h2>
<span id="more-3390"></span>Let’s say a station has 20 pairs of tickets to a hot concert. Which of these giveaway schedules gets the most attention?
<blockquote>
<ul>
 	<li style="text-align: left;">4 giveaways per day spread across 5 days.</li>
 	<li style="text-align: left;">2 giveaways per day spread across 2 weeks (10 days).</li>
 	<li style="text-align: left;">20 giveaways during the morning show on one day.</li>
</ul>
</blockquote>
Most programmers would choose #1. It seems logical to build a greater presence by creating multiple appointment tune-in times across as many days and time slots as possible.

The reasoning is that stretching the contest will create more promotional awareness. And to lure more listeners to try for the tickets will result in more listening. And, they can expose the promotion in more time periods.

But take a look at the third option. It’s hard to think about blowing out all of the prizes in one time slot on one day, isn’t it?
<h2>Create Special Events</h2>
There’s growing evidence #3 is the best tactic.

Amazon offers Amazon Prime Day as a special event to leverage <a href="https://tjohnsonmediagroup.com/blog/concentration-of-force/">Concentration of Force</a> with major discounts. They constantly offer sales and deals, but packaging a special, limited-time event as Prime Day creates buzz.

This works for radio stations, too. A highly concentrated promotion drives clear ratings gains.
<h2>An Example</h2>
I saw a presentation that showed results of a one-day event featuring a ticket giveaway every 15-20 minutes on just <em>one morning</em> drove significant increased listening.

For purposes of demonstration, let's call the promotion Timberlake Tuesday. The station had 20 pairs of tickets to give away, plus a grand prize of a chance to meet Justin Timberlake before the concert.

Instead of spreading the promotion over a week or two, they launched a Ticket Blowout event.

The morning show  is on from 5-10am. That's 20 quarter hours (5 hours x 4 quarter-hours per hour). Timberlake Tuesday promised a giveaway every 15 minutes all morning long. 20 giveaways on one show. And everyone who won a pair of tickets qualified for the grand prize announced at the end of the show. But to win the grand prize, listeners had to be tuned.

To build excitement, the station ran promos from the previous Wednesday through Monday.
<h2>The Ratings Proof</h2>
When the ratings results were analyzed, we discovered:
<ul>
 	<li>Weekly cume increased marginally, but <em>daily cume</em> on contest day increased by 15%.</li>
 	<li>Average quarter-hours grew by nearly 30%.</li>
</ul>
During the same ratings period, the station ran a similar promotion in a traditional way. They offered tickets to a concert over two weeks, promoting it heavily and across all time slots from 6 am to 10 pm.

The results showed no ratings impact. None.

I can’t share the actual data because it is proprietary information and my client wishes to keep the specifics private.
<h2>Reasons For The Success</h2>
There are several logical reason one day contests like Timberlake Tuesday work so well.

<strong>It’s More Exciting.</strong> Packaging giveaways in a shorter, defined time creates a greater sense of <a href="https://insidersradionetwork.com/starbucks-teaches-programmers-how-to-increase-ratings/">urgency</a>. It sounds bigger to promote “A pair of tickets every 15 minutes all morning on Thursday” than “listen for the next chance to win". In many ways, listeners have become numb to contests and promotion on radio stations.

<strong>It’s Believable</strong>. Typical contests are hard to play because listeners have to listen more than is convenient. And most listeners don’t think there's a chance they'll win. That's why typical <a href="https://insidersradionetwork.com/call-in-to-win-contests-dont-work/">call in to win contests don't work</a>. Many listeners, in fact, <a href="https://insidersradionetwork.com/promote-your-winners/">don’t believe the prizes are actually given away</a>. This addresses that objection, with winners on the air every 15 minutes.

<img decoding="async" class="alignleft wp-image-6335 size-medium" src="https://insidersradionetwork.com/wp-content/uploads/2018/01/Special-event-day-promotion-286x300.png" alt="" width="286" height="300" srcset="https://insidersradionetwork.com/wp-content/uploads/2018/01/Special-event-day-promotion-286x300.png 286w, https://insidersradionetwork.com/wp-content/uploads/2018/01/Special-event-day-promotion-768x805.png 768w, https://insidersradionetwork.com/wp-content/uploads/2018/01/Special-event-day-promotion-977x1024.png 977w, https://insidersradionetwork.com/wp-content/uploads/2018/01/Special-event-day-promotion-696x729.png 696w, https://insidersradionetwork.com/wp-content/uploads/2018/01/Special-event-day-promotion-401x420.png 401w, https://insidersradionetwork.com/wp-content/uploads/2018/01/Special-event-day-promotion.png 1004w" sizes="(max-width: 286px) 100vw, 286px" /><strong>It’s Easy to Play</strong>. Asking the audience to listen all week to try and win is a big ask. They just won’t do it. The only players are those who <em>happen to be listening</em> at the time of the giveaway. That's why most contests don't move the ratings needle. But directing attention to a specific time is easier to remember, and easier to play. All they have to do is tune in <i>any time on the big day</i>.

<strong>It’s More Promotable.</strong> The pre-promos are fantastic because there’s a specific call to action that builds momentum as the big day approaches. You could even count down to the launch. It sets appointments for the day and builds expectation. Timberlake Tuesday has  as much promotional presence as a typical promotion spread over two weeks, and a lot more excitement. The actual giveaways are just concentrated over a short period.

<strong>Concentration of Force.</strong> The principle of <a href="https://tjohnsonmediagroup.com/blog/concentration-of-force/">Concentration of Force</a> is powerful. It’s proven that more force directed at a small, defined target has greater impact. This is more proof of that theory.
<h2>Promotable Events Are Exciting</h2>
There's more data to support special events, shorter flash contests and programming that stands out.

We know that <a href="https://insidersradionetwork.com/surprise-your-audience/">listeners love surprises</a>. NuVooDoo research shows most stations do a poor job of exciting their listeners with programming ideas.

<img decoding="async" loading="lazy" class="alignleft size-full wp-image-6391" src="https://insidersradionetwork.com/wp-content/uploads/2018/01/surprise-the-audience.jpg" alt="" width="689" height="440" srcset="https://insidersradionetwork.com/wp-content/uploads/2018/01/surprise-the-audience.jpg 689w, https://insidersradionetwork.com/wp-content/uploads/2018/01/surprise-the-audience-300x192.jpg 300w, https://insidersradionetwork.com/wp-content/uploads/2018/01/surprise-the-audience-658x420.jpg 658w" sizes="(max-width: 689px) 100vw, 689px" />

</div>
</div>
<h3></h3>
<div class="vce-text-block">
<div id="el-74dd3309" class="vce-text-block-wrapper vce" data-vce-do-apply="all el-74dd3309">
<h3></h3>
<h3></h3>
&nbsp;

As you can see, only a small percentage of listeners are being stimulated with surprises on a regular basis.

This is especially revealing when you consider the responses are for <em>all </em>stations, not just their favorite station.

But perhaps the greatest reason to consider this tactic is that it appeals most to the audience that is hardest to attract.

My study of <a href="https://insidersradionetwork.com/excite-millennials/">millennial listener preferences</a> indicated an excitement for special events. In <a href="https://insidersradionetwork.com/generation-now-seminar/" target="_blank" rel="noopener">Fix Your Station For Generation Now</a>, we learned that today's young adults react to big events. They love specialty programming, big promotions and anything special that stands out.

One respondent even said:
<blockquote>We are simply bored with the same old same old.</blockquote>
<h2>Conclusion</h2>
It may be hard to reconcile giving away all promotional assets in one day contests or in one time slot. But programmers have succeeded with that philosophy for decades. Who hasn't conducted a weekend promotion that concentrates giveaways from Friday afternoon through Sunday, with a grand prize payoff on Monday morning?

This is taking that tactic one step further. And it makes sense because the world is moving faster and listeners have <a href="https://insidersradionetwork.com/affect-song-selection/" target="_blank" rel="noopener">shorter attention spans</a>. Plus, it's harder to stand out in a media world competing for attention. It's noisy.

This concept is exciting. It’s fun. And it sounds big!

Think about it. Heavy pre-promotion and creative post-promotion can cover as many days as a traditional giveaway. But the <em>impact</em> of one day contests or shorter-term giveaways can be much greater.

</div>
</div>
</div>
</div>
</div>
</div>
</div>
…
