Virtual
Storefront's &
Shopping Cart Solutions
Business Models for the Web
Virtual electronic businesses are being born
everyday on the Internet. They can allow one to open a business without the high price
office office space by building a store out of software.
Shopping cart applications are some of the
most popular, interesting to customize, and programmatically demanding CGI applications
currently in use on the web. Such applications allow companies to display their
inventories online such that clients can quickly and easily browse through and order items
of interest.
Some of the more famous and groundbreaking examples include Virtual Vineyards
<http://www.virtualvin.com/> and CD Now <http://www.cdnow.com/>. Both of these
sites generate tens of thousands of dollars from virtual clients through their
user-friendly interfaces and sleek design. Because warehouses are virtual and sales staff
automated, the virtual store is a profitable option for many small and mid-sized
businesses who gain instant access to a global market. Virtual Stores can also provide
larger, established companies with alternative outlets for their products as well as a
continued presence in emerging markets.
Further, clients receive the benefits of dynamic, customizable browsing tools. Rather than
deal with mail order catalogs, 1-800 numbers and faxable (or worse yet-snail mail-based)
order forms, a customer need only web over to their favorite store, click to their section
of interest, add some items to their virtual shopping cart, type in some shipping
information and submit the information over a SSL (Secure Socket Layer) channel of the
Internet. As David Cook writes in Launching a Business on the Web, "The idea of a
virtual shopping system is to make the job of picking products as painless as possible. In
essence, we want the user to do no more than simply point to a picture or word to purchase
an item."
Yet however invisible and seamless the application is to the customer, a shopping cart
system, is a demanding application to program, customize and/or install because it
integrates so many CGI functions into one system. Consider the complexity. A shopping cart
application must be able to manage every function of shopping; not only from the
perspective of the customer, but from that of the vendor as well.
Store Management
From the Vendor's Perspective
For one, the application must be able to manage and display the store's inventory. That
is, the application must be able to keep track of every item in the store's inventory and
be able to present them in an efficient and sensible way. Think of this function as that
of the store employee who must continually re-stock the shelves of the store with new
items, change some prices here, remove some items there, introduce "specials",
and generally make sure that aisles are clean, current, and organized for the convenience
of customers.
In terms of the shopping cart application, the program must be able to generate/display
browsable HTML "product pages" according to the needs of the client. These
product pages might be organized hierarchically, according to categories and
sub-categories of products or they might be generated dynamically based upon the
customer's search criteria. Further, depending on the desires of the vendor and the
demands of the inventory itself, the inventory might be physically stored as a flatfile or
SQL database or may be described as a series of pre-designed HTML pages. The shopping cart
system must be flexible and intelligent enough to produce a consistent look and feel while
all around is variable and changing.
A further complication lies in the fact that
every item must be uniquely identified and may have unique qualities which differentiate
it from other items, even within that same category. One good example of that is the
application of options. Many items, even within the same category may have different
options available for them. For example in an online music shop, certain albums might come
in CD format only, or in Tape or CD format, or even LP only. The application must have a
means for interpreting such unique qualities for every item and incorporate them into the
logic of the process. In a thousand item store, there may be a thousand "special
cases".
The Internet Store must also be able to keep track of many customers simultaneously and at
different times in their shopping process. Some of those clients might be just entering
the store. Some might be at the cash register. Others might be browsing the shelves
casually or with a specific product in mind. The Internet Store must be able to handle
each of these situations so seamlessly that each customer should feel as if she is the
only customer in the store. Speed and consistency are paramount.
Keeping track of visitors also involves a motley of administrative functions. For example,
just as someone must constantly keep track of used shopping carts at your local
supermarket, so must the Internet Store application deal with its own old, used shopping
carts. After all, it would not do to continually save all the carts used by all the
customers. If all goes well and your products attract droves of wandering webites, you
might generate hundreds of carts per day. Though each cart will be only a small text file
in itself, when combined, the set of all carts could cause your server's hard disk to fill
up quickly. Thus, the application must be responsible for pruning old carts at some
regular interval.
Another administrative function is that of logging accesses and errors. Every new client
will bring with her a set of valuable information which if gathered and interpreted wisely
could yield insights crucial to your continued success.
How many of your clients are international?
How many are repeat visitors? Which pages do clients most often request? Which items do
they most often buy? What percent of your visitors are smart enough to use Netscape? When
are your daily peak hours? These are the kinds of data which should be available in your
access logs for analysis.
Similarly, you should have a complete error log. Have there been any attempted hacks? Are
there errors in your configuration that slipped by you? Has some environment variable on
your server changed which demands your attention like a change in permissions? The error
log can be used to quickly diagnose problems with the application as it evolves to your
own needs. In some cases, a well analyzed error log can save you from having to hire a
programming consultant to do trouble shooting.
Finally, the Internet Store must be your cashier, totaling up shopping carts full of
items, and accepting payment from the customers. In doing so, it must be able to handle
your local taxes, shipping costs, discounts, specials and any number of surprise price
modifications, on the fly, for every customer.
More crucially, it must do this flawlessly and securely. Not only must the connection
between the browser and server be secure (an issue between you and your ISP), but orders
must then be sent securely from the server to the person handling order processing. What
good is a powerful (and expensive) SSL account if credit card and personal information are
sent unprotected via email. A secure store is only as secure as its weakest link. The
Internet Store must be able to support SSL technology as well as provide a secure method
of getting that information from the secure server to you.
Whatever the case, the application must be able to quickly provide a virtual store
environment with seamless access to products. At this infant stage of the web, there are
already enough barriers between the clients and vendors; speed, ignorance, unfamiliarity,
etc. The Internet Store technology must not add another barrier. It must be an interface
which makes the user want to come back.
Shopping From
the Customer's Perspective
A shopping cart system is also responsible for handling the needs of the
customer. It must follow each client through (even if their are dozens of\ clients
shopping simultaneously) the store acting as their shopping servant. When the customer
says grab this item, it must do so. It must also get more of one item or be able to put
all the items back on the virtual shelves if so instructed. It must do this for every
customer over several self-referential instances.
What is a "self-referential instance"? To answer that, a short discussion of
client server technology is in order. When you type enter a URL into the location window
of your favorite browser, you are becoming a client to some server from which you are
requesting some service. Typically, you will be asking the server to send you a document
formatted with hyper Hyper-Text Markup Language (HTML). In the case of a CGI script, you
ask the server to execute the program and send you back the results of the processing.
One of the facts of life with client server architecture is the fact that each request
sent from a client and processed by a server is considered a new and unique one. That is,
there is no real dialogue between you and the server. There is only a series of unrelated
queries and responses.
The server maintains no link with each client.
Instead it simply, blindly, automatically waits for a query, answers the query and settled
back down waiting for the next query to arrive. You may ask it for a second document with
another hyperlink, but the server will treat you as the unknown stranger you are. It will
not "remember" anything about you or your past interactions with it.
So how do you create a dialogue, a relationship; a complex relationship between a customer
and a vendor? For example, in order for each client to maintain a unique set of shopping
cart items, the application must keep track of each client and each client's virtual cart.
Maintaining state, as this is called, is difficult because HTTP, as we have mentioned, is
a "connectionless" protocol: every time a Web browser requests the attention of
your server, it is considered a new request, unrelated to any other requests fulfilled by
the server. Because each request is considered independently of others, the server has no
way to keep track of what clients have been doing in the past.
How then can the server "remember" what items you have already placed in your
cart? If you want to keep track of a client's activities from page to page (perhaps
keeping track of items that the client has ordered), your CGI application must find a way
to "remember" these transactions, because the server cannot.
After years of research we have found the best
way to do this and what we feel is the worst way to do this. One way is with the use of
"Cookies". Our way does not have to use Cookies.
Furthermore, the cart itself is a database
file that is built and modified on the fly based on the client's needs. The client must be
able to add and delete items from the cart as well as change the quantities of items
ordered. The maintenance of the cart, therefor requires a full-fledged database management
system.
Yet the script must do more than just display and modify shopping cart items that are
contained in the data file. It must also manipulate the database fields to perform price
calculations, such as subtotaling and generating grand totals from subtotals.
All this while still performing all the usual CGI functions like reading and parsing
incoming form data, checking that form data against bad input.
CyberAtlas:
The Retail and E-Commerce Segment: Market Reports
Nielsen
Interactive Services Interactive Services Internet Demographics Study
Contact Us |
