Six strategies for building a great Chrome extension
This guest post was written by Tal Raviv,
CTO of Ecquire
Even though the words "browser extension" connote a one-trick feature, today’s browser
extensions allow developers to accomplish some pretty amazing things.
Entire companies are
being
funded
and sold as extensions and providing serious value to users.
Here’s how you can make your browser extension a formidable product.
1. Use Your Superpowers
Developing an extension gives you advantages you may not have been aware of. Think of your
extension as an abnormally powerful front end. I'll name a few features we've especially
enjoyed:
- Let your users install very slickly directly from your home
website to increase
conversions.
- List on the Chrome Web Store for tens of thousands of free impressions. (Tip: For
maximum exposure and traffic, invest time in beautiful graphic assets.)
- Use localStorage as a super-easy store. Unlike in regular web applications,
localStorage for extensions remains untouched even if users clear their
cookies. (For more structured, asynchronous, client-side storage of large amounts of
objects, take
a look at IndexedDB.)
- Let Chrome sync your
extension across devices, including data you store in chrome.storage.sync.
Extensions are your chance to hack with
any
site you've wanted to improve beyond the limits of their API. There are many more
very powerful advantages browser extensions have - these are just the lesser known ones.
Check out
examples
and look at what other apps (even
silly
ones) have done. If you find yourself asking “how did they do that?”, check out the
source code.
2. Know What's Going On Inside Your App
Because extensions are front ends on steroids, you have your pick of almost any web analytics
software you choose. We recommend choosing an
event-based, not a page view-based model because the
definition of a page view is hard to interpret in most extensions. Instead, track specific
interactions.
We chose Mixpanel, but there's an official Chrome tutorial on
using Google Analytics in
an extension. The principles of implementation are the same no matter what you
choose.
Solid analytics help you answer questions about what's going on inside your app using hard
data instead of intuition and opinions. It will also undoubtedly reveal a few unexpected
surprises about user behavior.
3. Connect to Third-Party APIs
Good apps avoid reinventing the wheel, and great apps connect users to the services they
already like using. Extensions can request permission to connect with any domain. Just because
you're an extension doesn't mean you can't use OAuth to authorize those requests.
If your extension has a server backend, then fantastic, you have plenty of resources to help
you. If you want to directly make requests from the user's computer, that is completely
possible. The initial handshake and exchange of access token is done from a light server, but
after that you can save the tokens locally. This allows your extension to run all of its
interactions client-side if you'd like to
keep
things simple.
4. Make Money
Accepting credit cards and making financial transactions via an extension can be just as
ironclad and secure as anywhere else. There's no shortage of billing management services that
provide hosted payment pages and APIs.
Simply direct users to secure hosted payment pages to accept credit card information, letting
the billing service deal with compliance. We use
Recurly, which conveniently allows our users to use
coupon codes, receive invoices by email, and manage their billing info directly, saving us
even more development time and headache.
Hosted payment pages may be simple to implement, but they are
pretty powerful (see also
Chargify and
CheddarGetter).
They allow very specific management of your paying customers. Hosted payment pages can make
your extension aware of the user's subscription status, to deactivate or activate as
appropriate. Your customers’ payment statuses can be accessed with APIs behind the scenes
throughout the lifetime of your extensions.
If you prefer a super-streamlined flow for your customers - one where they potentially do not
need to enter their credit card information - using a hosted payment page from Paypal or the
recently
announced Google Wallet for
digital goods are your best bets for maximum coverage and quickest checkout.
Using hosted payment systems affords maximum functionality with the least amount of coding and
testing - or any server-side billing logic. Most importantly, you have peace of mind that your
customer's financial information is secure and compliant. No compromises.
5. Use Frontend Frameworks
Anywhere there's JavaScript, you can use
JQuery,
BackboneJS and
CoffeeScript: any JS library or plugin you love.
This applies across the extension architecture, from injected UI in content scripts to any
background code. The entire platform is web frontend - you can run anything you would use in a
web application.
6. Test All the Freaking Time
Okay, I admit it's a more fun motto to say than to do, but if you're a TATFTer, I have good
news for you.
Adrian Unger provides a how-to
on using
Jasmine BDD in
browser extensions even in the sub-cockles of your content scripts, even in the
context of a live, logged-in webpage.
Peace of mind about your code is important, but it's even more crucial in extensions where you
don't control the webpages you may be injecting into. You can use Jasmine to assert that the
DOM of your target web sites hasn't changed too much and that your code is still valid out in
the wild web.
In summary, just when you thought you knew everything you could do on the web, new doors open
up. This is just a small taste of our lessons learned about what puts browser extensions in
the league of extraordinary platforms. Like any new platform, I can’t even imagine the
innovation that has yet to launch.
Tal
Raviv is the CTO of Ecquire, a maker of CRM
workflow automation software. Capture contacts from anywhere and Ecquire puts it in
the right account for you. Read Tal’s guides on Chrome development and startup experiences on
the Ecquire blog.
Posted by Scott Knaster,
Editor