How Asking Visitors One Simple Question Boosted My Conversion Rate by 27%

One year ago, I was in-between jobs and living in my parents’ house. I was 28. Back then, my days consisted of two tasks:

1. Finding a new job
2. Doing whatever I could to earn money to help pay my bills while embarking on task number 1.

I am a former teacher and have an extensive background in test prep, so I decided to tutor at the local library for a little cash.

When I was not tutoring, I began writing test prep materials for a widely used pre-employment exam called the Wonderlic. Within a month, I launched a small website selling practice tests and a study guide for the Wonderlic test.

For anyone who is wondering what the Wonderlic is, I have a free practice test on my site that you can try.

Soon after the launch, I received an offer for a full-time gig and accepted.

I loved my new 9-5, but I also continued working on Beat the Wonderlic at night and on weekends, slowly growing it to the point where that business alone was completely covering all of my monthly expenses.

After a year, I decided to make the terrifying leap into full-time entrepreneurship and place all of my efforts into scaling my company.

Over these past few months of working on Beat the Wonderlic full-time, I have learned a great deal, but my greatest nugget of knowledge was acquired by accident.

My Conversion Rate Sucked — and Wasn’t Improving

I broke out my plan to scale three main pillars:

1. Lift conversion rate
2. Increase traffic
3. Boost AOV (average order value)

I started with focusing on conversion rate as investing in more traffic would be a waste of time and money if none of that traffic converted.

My conversion rate was hovering around a stagnant 1%.

Like many entrepreneurs, I (ridiculously) found this offensive.

This business was my baby. I was immensely prideful and protective of it. I also knew that it was the best Wonderlic prep product on the market – I had purchased all of my competitors' products, researched real Wonderlic tests, and knew that nobody in the market had a more complete and accurate study guide than the one I had created.

Naively, I thought this must be the problem — people don't know how great my product is… Maybe I should shout it from the rooftops so they understand the value of my study guide and then they’ll buy it!

Why My Initial Plan to Improve Conversions Didn’t Work

I planned to clarify and amplify what I thought was my value proposition.

I added bullets to the cover of my study guide, laying out all the reasons why I thought my customers wanted to know.

I added a PayPal badge to try to build trust with international customers, and I added an MSRP price to highlight how my product was less expensive than the competition.

I even decided to add a chat widget to my site in case visitors had any questions for me when they were browsing my site — and, better yet, maybe I could turn some of these questions into conversations and then, conversations into sales!

Now, the sum of these changes was important and did lift conversions, but it was certainly not the success I was expecting. My sales were still relatively stagnant, and I was getting desperate. If I could not lift conversions, my business would likely never grow, and I would have to go crawling back to my 9-5 begging for them to take me back.

Do You Know Why People Don’t Buy from You?

I was desperate to improve my sales. I needed to grow, and it needed to happen quickly.

I was in the admin view of my chat widget, watching as people entered my site, only to leave without purchasing moments later. I began to stare at the anonymous visitors as they landed, browsed, and left.

Continue reading %How Asking Visitors One Simple Question Boosted My Conversion Rate by 27%%

by Alex Hollis via SitePoint

Logging Errors in Client-Side Applications

Logging is an important part of any software application, both during active development and when it's running in production mode.

When you're working on the server, there are hundreds of libraries available to you regardless of your server-side language of choice, a wide range of storage mechanisms, and all sorts of tools you can use to work with the resulting logs.

However, when it comes to client-side applications, logging is something that often gets overlooked, and the options open to you are rather more limited.

In this article I'll look at some of the ways in which you can implement logging in a client-side application; particularly in a JavaScript-heavy, single-page application (SPA).

The Console

Perhaps the most common and obvious way to log errors and messages is the console. While it might appear a primitive solution, there's absolutely no doubt that it's an invaluable tool for debugging during development, so it's probably a good place to start.

The implementation of console isn't always consistent — particularly in IE, perhaps unsurprisingly — but in general there are four key methods available to you:

console.log()
console.info()
console.warn()
console.error()

The output from each of these four methods is subtly different, and most web console implementations (i.e., Dev Tools) allow you to filter messages based on the method used; that is, the logging level.

In order to mitigate the differences between browsers, you can use a wrapper function — such as this one from Paul Irish. The WHATWG is attempting to standardize the console API, but the spec is still at an early stage and unlikely to be implemented for some time.

Tip: If you find that your code is littered with console.log() statements, you might find tools such as grunt-remove-logging or grunt-strip for Grunt, or gulp-strip-debug for Gulp useful for when you move an application into production.

Enhancing the console

There are a couple of libraries you can use to "super-charge" the console.

Logdown

Logdown is a tiny library which provides a few enhancements to the console. You'll find a demo here.

Logdown allows you to specify prefixes upon instantiation; one possible use for this is to separate out your log messages by module, for example:

var uiLogger = new Logdown({prefix: 'MyApp:UI'});
var networkServiceLogger = new Logdown({prefix: 'MyApp:Network'});

You can then enable or disable the loggers by their prefix, for example:

Logdown.disable('MyApp:UI');
Logdown.enable('MyApp:Network');
Logdown.disable('MyApp:*'); // wildcards are supported, too

Disabling a logger effectively silences it.

Once you've instatatied one or more loggers, you can log messages using the log(), warn(), info() and error() methods:

var logger = new Logdown();
logger.log('Page changed');
logger.warn('XYZ has been deprecated in favour of 123');
logger.info('Informational message here');
logger.error('Server API not available!');

Logdown also provides Markdown support:

var logger = new Logdown({markdown: true}); // Technically "markdown: true" isn't required; it's enabled by default
logger.warn('_XYZ_ has been *deprecated* in favour of _123_');

console.message

console.message is another library for beautifying the console's output.

Here's a quick animation from the documentation, that shows off some of its features:

Essentially the library provides a chainable interface with methods which allow you to format text, group messages together and make them collapsible, send interactive DOM elements or objects to the log — and even include images.

Limitations of the console

The console is great while you're building an application and you can have it open in front of you, but unless you happen to be looking over a user's shoulders, and they happen to have the web console open in their browser, you won't get to see the result.

What we can do instead is send any errors — or even debug messages during development — to a server somewhere, so that we can access them remotely.

Other Things to Consider

Now that we've looked at some of the solutions available to you, let's look at a few additional considerations.

Capturing global errors

At the very least, it's worth capturing and logging any unhandled exceptions. You can do this using window.onerror. Here's a really simple example:

window.onerror = function(message, file, line) {
  console.log('An error occured at line ' + line + ' of ' + file + ': ' + message);
};

Stack traces

Stack traces provide an additional level of detail when an error occurs, which you may wish to make use of in development. There are a couple of libraries that help to build them.

TraceKit

TraceKit allows you to inject stack traces into exceptions, and do something with them (e.g. send them to your server-side logging component) by subscribing to them.

Here's what the code might look like:

TraceKit.report.subscribe(function yourLogger(errorReport) {
  //send via ajax to server, or use console.error in development
  //to get you started see: http://ift.tt/2ejuu03
});

Then, in your application:

try {
  /*
   * your application code here
   *
   */
  throw new Error('oops');
} catch (e) {
  TraceKit.report(e); //error with stack trace gets normalized and sent to subscriber
}

stacktrace.js

stacktrace.js is, to quote the documentation , "[a] framework-agnostic, micro-library for getting stack traces in all web browsers".

It provides a method named printStackTrace() which you can use in an error handler to add a stack trace to your logging function. For example, we could enhance our server-side logger as follows:

Continue reading %Logging Errors in Client-Side Applications%

by Lukas White via SitePoint

meSing.js – JavaScript Singing Synthesis Library

meSing.js is a JavaScript singing synthesis library that uses the Web Audio API's DSP capabilities in conjunction with the meSpeak.js speech synthesis library to provide a vocal synthesizer for the web.

by via jQuery-Plugins.net RSS Feed

Review: Extra – a New Type of WordPress Magazine Theme

If you’ve read some of my previous posts, I've reviewed the Divi WordPress theme by Elegant Themes. The makers of Divi have created a newer theme, centred more around bloggers and websites that publish a wide variety of articles and content types.

That theme is called Extra, and it has some pretty amazing and unique features. Let’s take a look at Extra, and some of the things you can do with that make it stand out.

Extra Contains All Divi Modules

If you’ve gotten used to creating your sites with Divi, then you’ll be pleased to know that all of the modules you’ve grown accustomed to are included with Extra.

You can still use the drag and drop page builder, with all of the layout modules you’ve seen in Divi. You can create nearly any layout, and customize it to your liking.

You’ll still have all of the options that come with each module, such as font choices, color choices, formatting, and the ability to add custom CSS to each module.

Where Extra Stands Out

Layouts

Extra gives you the ability to create custom layouts for your blog page, with the Category Builder.

Go down to the Divi menu in the admin section of WordPress, and one of the submenus will be called the category builder. This is where you will be able to construct your own blog pages. However, this doesn’t have to be confined to a blog page.

Continue reading %Review: Extra – a New Type of WordPress Magazine Theme%

by James George via SitePoint

Get Started on the CSS of the Future with PostCSS-cssnext

A discussion of PostCSS-cssnext appeared earlier this year in "7 PostCSS Plugins to Ease You into PostCSS", published by SitePoint. PostCSS-cssnext is a plug-in pack for writing next generation CSS. This article provides an insight into the project's history and its benefits. Once we gain a deeper understanding of PostCSS-cssnext, we'll then jump into a handful of examples for you to play with. By the end of the article, you'll be well-versed in future CSS syntax with PostCSS-cssnext, and be able to decide whether it is something you wish to use in an upcoming (or existing) project!

The Need for Next Generation CSS

Regardless of the language, developers are always after the latest features. Whereas tools like Babel provide JavaScript developers with support for future ECMAScript features, PostCSS-cssnext provides web designers with future CSS features. Currently, this means offering support for CSS4-related features, such as CSS variables, nesting, and more! Now, before we go any further, I would like to point out the fact that future CSS features can be subject to change, and the CSS4 spec is no different in this regard. Nonetheless, PostCSS-cssnext alleviates the negative impact this may have on a project by informing users in advance of any changes that are about to occur.

From cssnext to PostCSS-cssnext

Initially, "cssnext" was meant to perform such tasks as minifying code and displaying error messages. These capabilities were helpful, however they did not support future CSS features, which is the ultimate goal of the PostCSS-cssnext project. As a consequence, the cssnext team decided to abandon the idea of cssnext as a standalone tool on the grounds that the time spent supporting it could be better spent on supporting future CSS syntax and any of its subsequent changes. For additional CSS-related processes, developers can integrate PostCSS-cssnext with other technologies like cssnano for code minification and postcss-browser-reporter for error reporting.

Dissecting PostCSS-cssnext

If we delve into the PostCSS-cssnext repository on GitHub, we can see just how modular this plug-in is. Inside the src/features.js file, we'll see that the code for each future CSS feature is enclosed within its own module named in accordance with the relevant CSS specification.

Continue reading %Get Started on the CSS of the Future with PostCSS-cssnext%

by Thomas Greco via SitePoint

Use Indeed Prime to Get Matched with Only the Best Companies

This article was sponsored by Indeed Prime. Thank you for supporting the sponsors who make SitePoint possible.

Looking for a job in the tech industry can be an incredibly frustrating experience. You must find companies that are actively looking for employees with your skillset, and even when you find those companies there’s no guarantee that they are in a solid place financially or have a good reputation in the tech industry.

If you’re not careful, you can end up working for a company that is on the verge of running out of money or is known for shady business practices. Suddenly you find yourself in a scene from Silicon Valley with no hope of escape.

That’s where Indeed Prime comes in.

Indeed Prime helps software developers, product managers, data scientists, UX/UI designers, and sales professionals simplify their job searches and land their dream jobs.

Indeed Prime shares your job profile with truly vetted companies which have both financial strength and a solid reputation in the tech industry. This level of protection ensures that you get immediate exposure to only the best companies. No more inquiries from companies being investigated by the FTC.

When a company is interested in you, they will reach out with with salary, position, and equity upfront. This means no surprise 11th hour lowball offers. Additionally, if you are hired, Prime will give you a $2,000 signing bonus as a thanks for using Prime! Not only do you get your dream job, but you also get some extra cash up front.

Does Prime Indeed really work? The average software developer gets 5 contacts from employers and an average salary offer of $125,000.

Worried about your current employer stumbling on your profile? No problem. You can choose to hide your profile from select employers, ensuring you don’t get pulled into any awkward conversations with your boss.

The best news? Indeed Prime is 100% free for job seekers! And if you refer a friend and they get hired, you get a $2,000 referral bonus. Please use this link to refer your friends.

Currently, Indeed Prime is focused on matching candidates with opportunities in Austin, Boston, San Francisco, Seattle, New York City, Chicago, Los Angeles and London, with plans in the works to soon expand the list of cities.

To get started with Indeed Prime, click here.

Continue reading %Use Indeed Prime to Get Matched with Only the Best Companies%

by Stephen Altrogge via SitePoint

Creating a Backend for Your iOS App Using Firebase

Firebase is a Backend as a Service platform that can help you quickly develop and deploy your application. It provides a myriad of features including Realtime Database, Authentication (with email and password, Facebook, Twitter, GitHub and Google), Cloud Messaging, Storage, Hosting, Remote Config, Test Lab, Crash Reporting, Notification, App Indexing, Dynamic Links, Invites, AdWords and AdMob.

In this article, we'll create a simple To Do app that will show how to save and retrieve data from Firebase, how to authenticate users, set read/write permissions on the data and validate the data on the server.

To get started, first download the started project that we'll use in the tutorial and then head over to Firebase and create an account if you don't already have one.

The Login view has a Register button that takes you to the Sign Up view when tapped; and on this view, there is a Sign Up form as well as a Login button that takes you back to the Login view.

To add the Firebase libraries to the project, we'll use CocoaPods. First make sure that you have CocoaPods installed on your computer.

Open Terminal and navigate to the root of the downloaded project with cd Path/To/ToDo\ App (the \ escapes the whitespace in the directory name).

Continue reading %Creating a Backend for Your iOS App Using Firebase%

by Joyce Echessa via SitePoint