5 Tips To Creating A More Usable E-Commerce Site

E-commerce is a very competitive field because your rival is no more than a click away. If a customer doesn’t like your site, he simply looks for another e-commerce site to buy products from. If you want to gain more customers and attract attention, you want to make sure that your website is as usable and as customer-friendly as possible.

It doesn't matter if your prices are very low or you have the best products in the market because if customers get confused navigating your website, reaching a preset target will likely be difficult.

Usability means that you have to make the buying process as quick and as easy as possible. These tips will let you create a more usable e-commerce website that can create higher conversion rates.

1. Call To Action & Sign-Up Buttons

Avoid lengthy sign-up forms that can take a few pages or so before visitors can successfully register to your site. As an e-commerce site, you don’t actually need to know their address, phone number, what kind of work they do, etc. A simple email address and a password are just all you need. That being said, never underestimate call-to-action buttons as this help in building higher conversion rates and improving site usability. Make these call-to-action buttons stand out.

2. Buying Without The Need To Register

One thing online shoppers hate the most is the long and tedious sign-up process before finalizing a purchase. What if you go about allowing guest users to checkout products without the need to register, then ask them afterwards if they want to sign up, to make the next purchase on your site easier? This kind of method is known to increase sales (up to the tune of $300 million), improve customer retention, and reduce cart abandonment.

3. Search Function

Search functionality helps customers to find what they are looking for, making their shopping experience more satisfying than frustrating. Who would want to go from one page to another, read the description of every product you have in your online store, just to find what they are looking for these days?

4. Breadcrumb Navigation

When placing orders, customers have to know where they stand in their purchase process – how many steps have they accomplished, and how many more to go. Without breadcrumb navigation, customers will easily get bored and think your shopping procedures take forever, making them more likely to just abandon their purchases, halfway through.

5. Shopping Cart

No e-commerce website is complete without proper content management and personal detail security. Shoppers should feel confident in buying products at your e-commerce site, so you need to assure them that your site is a reputable site that has features to protect the privacy of your customers. Get a trust certificate like Hacker Safe or VeriSign and an updated SSL certificate to build up customer trust and offer better shopping security.

Suggest Related Items

The way Amazon.com suggests related items, like batteries, accessories and peripheral products when a buyer is purchasing a laptop, not only help save the customer’s time but also helps increase revenue and customer retention on your e-commerce site.

Hidden Charges

Customers hate agreeing to the price of a product only to find out that it is going to cost them 2% more when it is time to share their credit card details. Make sure that you display prices, taxes, shipping charges, discounts early, so that buyers know the final sum they will be forking out.

If you present your customers with a lot of unexplained costs, they will more likely to abandon their purchase, and even worse, their trust in your site will be broken.

10 Ways to Deal With Upset Customers Using Social Media

1. You Can’t Respond to Conversations You Don’t See

Great response starts with great listening.

Set up Google Alerts for your brand and industry keywords.

Keep a close eye on your Facebook page.

Listen on Twitter.

Depending on the type of business you have, read reviews on sites such asYelp, TripAdvisor and Zagat.

Make a list of any forums or communities where your customers congregate andregularly check in on them.

Whether you’re paying attention or not, the conversations are happening. But a great listening program makes it easier for you to catch negative buzz and spot issues before they build momentum and become much harder to turn around.

Google alerts are free, easy to set up, and instantly help you keep an eye on key conversations.

2. Determine if it’s Worth a Response

Not all negative comments are worth a response, and not all critics are worth trying to win over. Sometimes, as hard as it can be, it’s best just to move on.

Avoid these situations:

• The criticism is on a really small blog or forum, and your response will only bring attention and credibility to an issue nobody saw in the first place.
• It’s a blatant attack that’s clearly rude and outrageous—and anyone who reads it can see the critic has a personal problem.
• A known crackpot who is only looking to pick a fight.

There’s just no way to win in these scenarios. So stay out, move on, keep your head up and focus on the wrongs you can right.

3. Act Quickly

When you’re facing negative word of mouth, time is not on your side. The longer you wait to respond, the angrier the customer will get—and the more likely others will pick up on the issue and spread the negative buzz.

At the very least, say this:

“Hi, my name is ____ and I hear you. We’re looking into it now, and I’ll get back to you as soon as possible. If you have any questions, contact me directly at _____.”

A message like this does two things:

• The ranter knows he or she has your attention—there’s much less incentive to keep spreading the anger and
• It makes a real person with real contact info available, so if the person is still angry, you’ve at least specified a place to vent other than online.

4. Speak Like a Human

The only thing worse than ignoring upset customers is to respond with a canned corporate response. If you thought they were mad before, wait until you see how they react to an excerpt of your policy terms and fine print.

Show empathy, communicate in a friendly tone and use your real name. And if the forum supports it, it helps to include your actual photo.

It’s easy to yell and scream at an anonymous company. But when someone shows up and says, “Hi, this is Emily and I’m so sorry for the trouble…” it changes everything.

The critic now realizes he wasn’t yelling at a giant, faceless company. He was yelling at Emily. Quickly, the anger fades—and you’ll often get an apology.

Check out how Zappos replies to this fan. It’s human; it’s friendly. And even though they couldn’t immediately fix the problem, you can bet this fan will be back.

Check out Zappos’ Facebook page for a real-time guide on how to respond in a personable, friendly tone.

5. Offer a Real Apology or Don’t Apologize

A strong, direct apology will always earn more respect than a flimsy, “kinda-sorta” apology.

Consider the difference between an apology like “We’re sorry you feel that way” to “Absolutely, positively unacceptable”—which was the headline to FedEx’s blog postafter a delivery driver was caught throwing a package over a customer’s fence. The post included this straightforward video from Matthew Thornton, a senior vice president at the company:

And it doesn’t get much better or more direct than Jeff Bezos’ apology for how they handled pulling copies of 1984 and other novels off Kindles:

This simple, straightforward apology from Jeff Bezos drew more than 750 overwhelmingly positive responses.

6. Offer to Make it Right

Apologizing is part of turning around negative word of mouth, but to actually fix a problem is how you really win over critics.

We all make mistakes. It’s how we fix them that people remember.

At burrito chain California Tortilla, making it up to customers is part of every response they send when someone is upset. It’s this simple:

California Tortilla replies to every upset customer with a simple, straightforward offer to make it up.

7. Never Get into a Fight

Any time you win an argument online, you’re losing. All anyone really remembers is that you’re combative.

This doesn't mean you can’t respond, explain your side of the story and start a conversation. You just need to be in the right mindset:

Don’t get emotional.

Remember, it’s a real person. Just as they see you as a faceless company, it’s easy to see them as just another complainer.

The critic is actually doing you a favor. They’re helping you learn to be a better company. For every person who actually speaks up, many more walk away quietly, never to return.

For more on how to reply, check out this quick explanation from Jeff Diamond of Oakland’s Farmstead Cheeses and Wines:

8. Keep the Discussion in the Open

When a negative issue comes up, a common gut reaction is to ask to move the conversation offline. But when you do this, the world can’t see all the effort you put into fixing the problem.

Nobody sees the private email where you give that sincere apology. We can’t search for that phone conversation where you politely explain why the situation happened in the first place.

But when you do it online, in public, you earn word of mouth. For the same effort and cost, thousands more people see that you actually care about customers. Plus, you save on all the people who now don’t need to call in (or write a similarly angry post) to find an answer to the same question.

Graco’s quick and transparent use of Twitter during a recall of more than 2 million strollers, for example, helped get an important message out much more quickly, showed customers how much they cared and it just might have saved some lives, too.

Customers were thrilled with how Graco kept them updated and informed during a product recall.

9. Use Fans and Third-Party Sources to Help Tell the Story

What you say about yourself isn’t as powerful as what others say about you. It’s true when people are promoting you, and it’s true when people are calling you out.

When their brand was under attack from a competitor-led PR campaign, UPS’ Debbie Curtis-Magley and her team pointed to third-party content from news articles and industry experts to help explain the full story.

And even more powerful than experts can be the voice of your fans. You never want to put them in an uncomfortable situation, but it’s OK to ask for help sometimes.

For example, a blogger might share how he’s frustrated with a particular product feature. In which case, you might turn to your Facebook or Twitter fans with this message:

“Hey guys! Chris over at [blog name] is having trouble with [feature]. Can anyone share how they’re using it?”

10. Involve Them in the Fix

If someone’s criticizing you, it’s often just a form of tough love. They’re doing it because they care. They see potential, and they want you to do better.

So instead of seeing them as critics, start looking at them as frustrated fans that might have some worthwhile ideas.

On one hand, Dell’s IdeaStorm is just a big list of things people think they’re doing wrong. But it’s actually a release valve—a proactive community that gives people with ideas, suggestions and complaints a place to share and vote on their favorites.

Every idea on Dell’s IdeaStorm can be voted up or down, and Dell keeps everyone updated on progress.

A platform like IdeaStorm isn't right for everyone, but giving your biggest critics a way to get involved is. Try inviting yours to customer advisory boards, beta tests of new products and brainstorming sessions.

See! Negative word of mouth doesn't have to be so bad after all.

How do you handle critics? How are you making the most of negative word of mouth?

How are you responding to upset customers? No matter what you sell or what industry you’re in, you’re going to experience negative word of mouth. You know, those customers who are expressing their complaints on social media.

It just happens.
Things break, problems come up and employees have bad days. But it’s how you handle it that separates you from everyone else.

Remember: Negative word of mouth is an opportunity.

A great response strategy can convert angry and upset customers into loyal, raving fans. The rule of thumb is that while unhappy customers talk to 5 people, formerly unhappy customers you win back talk to 10.

So get out there and embrace the negativity. Start responding. Here are 10 steps you can take to stop the negative, earn new fans and generate a ton of respect.

Test Driven Development - TDD

Test-driven development (TDD) is a software development process that relies on the repetition of a very short development cycle: first the developer writes an (initially failing) automated test case that defines a desired improvement or new function, then produces the minimum amount of code to pass that test, and finally refactors the new code to acceptable standards. Kent Beck, who is credited with having developed or 'rediscovered' the technique, stated in 2003 that TDD encourages simple designs and inspires confidence.^[1]

Test-driven development is related to the test-first programming concepts of extreme programming, begun in 1999,^[2]but more recently has created more general interest in its own right.^[3]

Programmers also apply the concept to improving and debugging legacy code developed with older techniques.^[4]

PHP Interfaces

Lots of developers struggle to grasp the concept of the "interface" in PHP. But once they get the idea and understand how it works, they then struggle with a new problem: writing interfaces that are too complicated.

This might seem like a contradiction in terms: after all, we want to create comprehensive interfaces that describe the behaviour of a particular object type. And since we don't generally want to extend the interface, shouldn't the interface we write be complete?

Yes, and no. Let me explain.

The overbearing interface

Let's take a look at a common database interface that many of developers come up with when they're tasked with writing a database layer:

<?php
    interface MyDBObject {
        public function connect($host, $db, $user, $pass);
        public function query($query, array $params);
        public function prepare($query);
        public function beginTransaction();
        public function commit();
        public function rollback();
    }

This interface looks good: it handles the connection and the connection-level functionality without adding in query-specific behaviours. That's what we want.

But then let's pose the question: what happens when you encounter a database that doesn't support transactions?

Most modern databases are ACID compliant. But some still aren't. And what happens when you have to implement one of those?

Their answer is often to simply leave the transaction-aware methods blank. But this is a problem, because the Interface Segregation Principle says that no object should be required to implement a method it doesn't use.

Oops.

Fixing the interface

PHP doesn't require that we use a single interface for each object we create. In fact, the beauty of PHP interfaces is that we can implement lots of them, even though we don't have the ability to do multiple inheritance.

So, to solve this problem we can break this interface into *two separate interfaces*:

<?php
    interface MyDBObject {
        public function connect($host, $db, $user, $pass);
        public function query($query, array $params);
        public function prepare($query);
    }

    interface TransactionAware extends MyDBObject {
        public function beginTransaction();
        public function commit();
        public function rollback();
    }

There, now we have two interfaces we can use. Great! This lets us implement only those methods we need for older, non-ACID compliant databases, while giving us the methods we need for modern database applications.

Avoiding "God" objects

Another common error is the creation of an interface that does *everything*. Even if a behaviour is in scope for a particular object, that doesn't mean we should necessarily implement it in this object.

Let me explain.

The Imagick library in PHP has a single object that has literally hundreds of public methods. The object interface is huge.

This is a classic "God" object. The object is enormous, and probably does far more than it should.

My general rule of thumb is that an object should have no more than six to eight public methods or it is probably overreaching. Of course, this is not a hard and fast rule: there are many objects with a single role that have ten or twelve methods. But it is a good rule for the start of the evaluation process, and for taking a hard look at your object.

The bottom line

Creating an overbearing object or an inflexible interface is a good way to end up with objects that describe behaviours that are out of scope or not even implemented. We want to avoid both. Discrete, clean interfaces are preferable in all cases, and that's what we should strive to achieve.

Refactoring and Kata

Martin Fowler has a pretty good site on refactoring - http://www.refactoring.com/

Coding Dojo Katas - http://codingdojo.org/cgi-bin/index.pl?KataCatalogue

PHP TDD Shopping Cart from scratch.

So, I've finally taken the plunge again and started seriously looking into refreshing my dusty old brain cells about TDD and unit testing.

Over the past few weeks I have been re-reading various books, reading articles and watching video-casts by some of the leading names surrounding Testing, TDD, Design patterns and tackling legacy code, and the inspiration has finally got to me that I just need to tackle this head on.  Consuming a wealth of information about greenfield and brownfield systems and how to tackle them.

I have also revisited daily coding Kata's, taking 15mins in the morning or evening to tackle a simple Kata to get my brain in "test first" mode.

The array of books and information I have consumed has been immense and I'll probably re-read and watch everything again, and get a different perspective on things, although I guess the main way to learn is by doing, which is why I raked through the archives (then ended up password resetting) my github account to allow me to post updates to here with my personal coding ventures.  I have only hooked up tonight's work, but I do hope to get a few of my Kata's in there for people who haven't seen them before, as well as links to where you can find these for practicing yourself.

Tonight's project has been getting the basis of a shopping cart system up and running TDD style. So you'll see at my github account, I've literally written 3 tests and a few lines or production code.  There is quite a way to go, but I do hope to take time and regularly update and work on this as a reference for anyone who wants to follow along or help out.


Well enough typing for tonight, here are a quick list of links to some resources I've been consuming the past while.

Github - https://github.com/williamcameron/tdd-cart
Art of Unit Testing - http://artofunittesting.com/ and http://www.amazon.co.uk/Art-Unit-Testing-examples/dp/1617290890/
Various Roy Osherove talks and videos on youtube.
Working Effectively With Legacy Code - http://www.amazon.co.uk/Working-Effectively-Legacy-Robert-Martin/dp/0131177052
Refactoting Existing Code - http://www.amazon.co.uk/Refactoring-Improving-Design-Existing-Technology/dp/0201485672/

Why you should never extend the interface

Hello, there
What's wrong with this code sample?

<?php
    class MyClass {
        public function myFunction() {
        }
    }
    

    class myOtherClass extends MyClass {
        public function MyOtherFunction() {
        }
    }
   
    class Controller {
        public function doSomething(MyClass $object) {
            $object->MyOtherFunction();
        }
    }



On first blush, it might seem that this is ordinary inheritance, and we're doing everything we should be doing. But there's something very wrong here.

The problem here is that we're extending the interface. Extending the interface itself isn't necessarily bad, but we're making a second mistake: we're then typehinting on the wrong object type.

Let's talk about why we want to avoid this practice.

The Liskov Substitution Principle
I've discussed the Liskov Substitution Principle a few times through this newsletter. But let's go over it again.

The Liskov Substitution Principle says that one object should be replacable with another object of the same type, without breaking the program.

In other words, all objects of type A should replace one another, and the application should work just fine.

But our code sample above has a big problem: we're typehinting on one object type (MyClass) but we're relying on the interface of a different object type: myOtherClass. This means that if we actually pass in an instance of MyClass, our application will break.

Let's fix it.
So, now that we know what the problem is, how do we fix it? There are three different possible solutions.

1. Treat as abstract. First, we can treat MyClass as an abstract class, and mark it abstract. We can then include the abstract method definition, but not the code. This fixes our typehint.


<?php
    abstract class MyClass {
        public function myFunction() {
        }
    

        abstract public function MyOtherFunction();
    }



Once we've done this, our typehint is accurate and we don't have to worry about the method we want not existing, because the abstract definition guarantees it.

2. Change the typehint for the object being used. Instead of fixing the base class, we can fix the typehint and typehint on the actual object type we want. This solves the problem by ensuring that we are telling the application precisely what to expect.

<?php
    class Controller {
        public function doSomething(MyOtherClass $object) {
            $object->MyOtherFunction();
        }
    }


Of course, we are now hinting on a specific object, instead of an interface. But this is still better than relying on an interface that may or may not exist in future.

3. Define different interfaces, and hint on the one we want. It's possible in PHP to define two interfaces, and implement both of them in the same object. For example:


<?php

interface MyClass {
  public function myFunction(); }
  

  interface myOtherClass extends MyClass {
    public function MyOtherFunction();
  }


With these two interfaces, we can typehint on the interface we want, but leave the implementation details up to the future object that's going to be created. We're still guaranteed a particular interface, and this makes it easy to follow the Liskov Substitution Principle.

Objects know one another by their interface.
Regardless of the solution you might choose, there's one rule that you have to remember and understand: objects know each other by their interfaces.

The public methods form the "interface" or "API" that other objects use to communicate with a given object. Outside objects know nothing of the internal protected and private methods an object has; they can't use them. So, an object's interface is the only way to describe it to the outside world.

This interface therefore define's an objects type. In PHP, interfaces can't define anything besides public methods, and this is by design: when we typehint, we're saying "give me an object that has these methods."