Bounce Rate optimization for publishers, using “Exit Intent”

Understanding Bounce rate

First off, according to Google Analytics

Bounce Rate is the percentage of single-page sessions (i.e. sessions in which the person left your site from the entrance page without interacting with the page).

Important caveat: Bounce rate in GA is actually calculated as a single “pixel download” (_utm.gif) per session. So if you trigger a subsequent custom event, you could be inadvertently disguising an actual bounce since events also trigger pixel downloads by default. You can override this behavior  by using "non-interaction" events .

On a news site, blog, or any site where Ad impressions are a revenue producing goal,  Bounce Rate can be a key indicator. If you haven’t really dug into how Exit Rates differ, you should give Exit Rate vs Bounce Rate a read. 

Why do we care? Because by simply reducing bounce rate (without decreasing user sessions) we would directly increase overall Pageviews. Yay Goals!

So what is Exit Intent?


Exit Intent is just a way to detect a user navigating towards the top of the browser in a way that suggests they are about to leave your website. Pretty simple actually.

Targeting users with “Exit Intent”

"Exit Intent Targeting" is definitely not a new concept… a lot of e-commerce sites have been using this tactic for many years by displaying a popup or overlay window to offer some discount right before you “bounce”. More info at http://exitintentpopup.com 

There are even quite a few services on how to implement this concept on your site, like OptKit, OptiMonk, Bounce Exchange & ExitIntent 

Personally, I like having control/understanding of the javascript, so a really nice implementation is available on Github @ https://github.com/carlsednaoui/ouibounce


Good idea for publishers?

So this is all cool stuff that COULD be easily tested on your site in a non-invasive way, but the real question (for me) is how this tactic should be used on a news site or blog and whether the impact would be worth the effort.

Either way, I plan to test out this technique in a few different ways to entice visitors to click “one more time”. Possible techniques could use; ‘Breaking News’, related stories, or a targeted newsletter signup.

Comments are always greatly appreciated. 

- Brad


SnapCard: the business card app you actually want

An alternative to physical business cards. When someone asks for “your card” just show them SnapCard and have them take a pic.


Leave some feedback.

Download for for iPhone and Android today. 

image     image


My “Key Management Principles” (KMP)

~~ re-post from Nov 2008 ~~

Below are a few of the main principles I try to practice on a daily basis and also try to pass on to people I work with. The prime reason for this; is that they are based on common sense and haven’t proved to be wrong yet. Some of the principles below may seem solely oriented towards software development, but they also apply to an agile project management style.

YAGNI, short for ‘You Ain’t Gonna Need It’, suggests to that they should not add functionality until it is necessary. Ron Jeffries writes, “Always implement things when you actually need them, never when you just foresee that you need them.”
The temptation to add features that are not necessary at the moment, but might be in the future, has the following disadvantages:
• The time spent is taken from adding, testing or improving necessary functionality.
• The new features must be debugged, documented, and supported.
• Any new feature imposes constraints on what can be done in the future, so an unnecessary feature now may prevent implementing a necessary feature later.
• Until the feature is actually needed, it is difficult to fully define what it should do and to test it. If the new feature is not properly defined and tested, the unnecessary feature may not work right, even if it eventually is needed.
• It leads to code bloat; the software becomes larger and more complicated.
• Unless there are specifications and some kind of revision control, the feature may not be known to programmers who could make use of it.
• Adding the new feature may suggest other new features. If these new features are implemented as well, this may result in a snowball effect towards feature creep.

The K.I.S.S. principle or “Keep It Simple Stupid”, states that design simplicity should be a key goal and unnecessary complexity avoided. It serves as a useful principle in a wide array of disciplines, such as software development, animation, journalism, photography, engineering, and strategic planning.
"Everything should be made as simple as possible, but no simpler." – Albert Einstein

Occam’s razor
Occam’s razor, often paraphrased as “All other things being equal, the simplest solution is the best.” In other words, when multiple competing theories are equal in other respects, the principle recommends selecting the theory that introduces the fewest assumptions and postulates the fewest entities. It is in this sense that Occam’s razor is usually understood.

Last Responsible Moment
The key is to make decisions as late as you can responsibly wait because that is the point at which you have the most information on which to base the decision. In software design it means you forgo creating generalized solutions or class structures until you know that they’re justified or necessary.
Making decisions at the Last Responsible Moment isn’t procrastination; it’s inspired laziness. It’s a solid, fundamental risk avoidance strategy. Decisions made too early in a project are hugely risky. Early decisions often result in work that has to be thrown away. Even worse, those early decisions can have crippling and unavoidable consequences for the entire future of the project.

Core Principles of Agile
1. Individuals and interactions over processes and tools
2. Working software over comprehensive documentation
3. Customer collaboration over contract negotiation
4. Responding to change over following a plan

(Source: brad.w3portals.com)


"if-equal" helper for Express Handlebars

I’ve been using express-handlebars templates with NodeJs + Express for a few weeks and really beginning to like it. 

Here’s a nice helper to add some conditional logic to your Handlebars templates. 

exports.ifEqual = function(val, test, options) {
  var arrTest = test.split('||');
  for (var i = 0; i < arrTest.length; i++) {
    if (val === arrTest[i]) {
      return options.fn(this);
  return options.inverse(this);

So now, in your template, just use:

   {{#if-equal story.type 'video||photo'}}
       < h1> Show me if type is video or photo< /h1>

And creating this, I realized there are a bunch more over @ Assemble.io



Election Poll builder for Bootstrap


Yes way! Well, kinda.


See demo @ http://bradoyler.github.io/HTMLPollBuilder/

Github repo @ https://github.com/bradoyler/HTMLPollBuilder 


DasHub: A dashboard for Github Issues

DasHub is a lightweight (kanban-style) tool to make GitHub Issues more visible and manageable to teams using Github for issue tracking. 

The entire application is written in javascript using Ember.js

Source on Github



- Ember.js
- Ember App Kit (EAK)
- Github issues API
- Client-side basic auth
- Javascript
- Sass

Upcoming Planned features

Get at me… fur sure. workaholics


A web component for the Weather

A card-style weather HTML5 web component example using Polymer.js.

<Source on GitHub/>



- Meteocons: weather condition icon fonts 
- WeatherUnderground API
- HTML5 Geolocation api
- HTML5 localstorage
- Polymer.js


Photography makes us feel closer to the world than we really are.

Susan Sontag


Creativity is allowing yourself to make mistakes. Art is knowing which ones to keep.

Scott Adams


git reset —hard

&& git push —force



Front-end tools brought to you by Twitter

Twitter has ‘contributed’ a lot to the open web. Here are a few examples.

  • Flight.js - a lightweight, component-based JavaScript framework  (started ~Jan 2013)
  • Flight-generator - a Yeoman generator to Flight.js
  • Jasmine-Flight - a set of Jasmine helpers for testing your Flight.js app
  • Hogan.js - a mustache-based js template compiler 
  • RECESS - a CSS style hinter on top of LESS 
  • Bootstrap - although no longer maintained by Twitter, I had to mention this ubiquitoius CSS framework. 
  • Typeahead.js - a fast and fully-featured autocomplete library

And yes, there’s more back-end stuff too. See the full list of repos @ http://twitter.github.io/ 


Rise of the Static Site generators

  I’ve seen a serious uptick in new web publishing projects, over the last 6 months. I think a lot of web developers are pretty unsatisfied with the current approach to the creating content on the web. Stuff like Wordpress, Drupal, Tumblr, Movable Type, etc, all have there pain points, shortcomings, and serious baggage. 


So… we enter a “old but new” wave of how to publish to the web. Albeit, the new shiny platforms are built for developers, but keep an eye out for Jekyll-inspired static site platforms like Harp, Roots, Punch, DocPad & Wintersmith because they could be a strong indicator of what’s coming down the pike.

The common tools used across all these platforms seem to of course be the trendy ones: Javascript, Node.js, Express, Markdown, Jade, Stylus & Coffeescript.



Little problem this morning, going to work…



An Agile Approach

I’ve worked on a few Agile\Scrum projects since 2006 and just wanted to share some notes that I think might be helpful.

The Project roadmap

A roadmap is a high-level plan that describes how the product is likely to grow. The Artifacts (below) of the roadmap are not deliverables, since they have no value to the customer. It is key, that the roadmap be owned by the entire team. Therefore, everyone should contribute to creating and modifying these artifacts.


- User Story: a way to describe a piece of functionality that an end-user wants.

- Epic: A large story that most likely be broken down into multiple stories later on.

- Theme: simply a collection of user stories. However, user stories may belong to multiple themes.

- Spike: A technical issue that needs to be figured out or experimented with before tackling an Epic, Story, or Theme.


Daily standups

Please take care with these. Don’t make this a place for everyone to rattle off what they’re working on or direct questions to specific team member. All comments/questions should beneficial to the team. In other words, status updates are for your Facebook friends.

Planning meetings (every 2 or 3 iterations)

- Talk about MMFs (minimal marketable features)

- Prioritize into Themes & Epics

- Retrospectives: The team shares what has worked well and was hasn’t. The good, the bad & the ugly

Iteration meetings (weekly or bi-weekly)

- Re-evaluate the top priority items. This is the team’s chance to adjust direction.

- Create the user story drafts (as a team)

- Estimate user stories (difficulty scoring: 1-5)

*Agile also includes many of the Scrum and XP principles, but in the theme of being “Agile”, trying to stay lightweight with this post. 

The most important part is to continuously make adjustments until a process works well for the team. These terms and practices really just serve as an agreed upon language for the team. Which helps foster efficient communication for the team and also other stakeholders.

A great talk from James Shore on "The Art of Agile"