The short answer
Build an online store in this order: decide what the store is for, turn your products into a clean catalog, build the full shopping path from homepage to checkout, set up payments, shipping, and taxes, then test, connect the domain, and publish. Before you send customers, place one real order, follow it through to packing, and refund it. With ten complete products and your own photos, that sequence fits in one to two weeks. AI can build and refine the storefront for you, but you still approve the facts, the commercial rules, the presentation, and every test that touches money.
Setka is our product, and this guide shows where it changes the work: it builds the whole storefront from your brief and catalog, so the theme-and-apps stage that usually sits in the middle of this list never starts.
The complete store-building process
A store is a connected system. Product information shapes category pages, categories shape navigation, shipping and tax rules shape checkout, and the order workflow decides whether a paid purchase can be fulfilled correctly. Working through these parts in order keeps attractive pages from hiding operational gaps.
BUSINESS INPUTS
offer + audience + constraints
|
v
CATALOG FOUNDATION
products -> categories -> images and brand assets
|
v
STOREFRONT
homepage -> category -> product -> cart
|
v
COMMERCE SETUP
checkout -> payment -> shipping -> tax
|
v
CONTROLLED REVIEW
content -> mobile -> test purchase -> order handling
|
v
RELEASE
domain -> publish -> validate -> operate
Feedback loops:
review can return to any earlier stage; the catalog remains the source of truth.
Only the top level is linear. In practice, review sends you back: a crowded menu exposes weak categories, an image needs a new crop, or a shipping rule needs clearer wording on the product page.
1. Decide what the store is for
Start before layouts and colors. Write down the commercial choices the store must express:
- Offer: what you sell now, what is excluded, and whether the products form one coherent range or several distinct ones.
- Audience: who is most likely to buy, what brings them to the store, and what they need to compare.
- Positioning: why this range is a relevant choice, stated without claims you cannot prove.
- Primary action: usually shopping a category or opening a product, rather than reading a long brand story.
- Operational boundary: where you ship, which payments you accept, how taxes apply to your business, and who handles orders.
Reduce these answers to a short brief: tone, visual references, logo, colors, factual brand notes, priority categories, catalog size, price range, and launch constraints. Every later output gets judged against it. Our guide to writing a store brief covers each part with an example.
Then complete this sentence: “This store helps [customer] choose [product range] for [need], with confidence based on [real evidence].” If the sentence comes out vague, the homepage and categories will too.
2. Build a reliable product catalog
The catalog is the source material for the storefront. Give each launch product a clear name, accurate price, factual description, category, identifier, availability status, shipping information, and a usable image set. Normalize repeated values such as units, materials, sizes, and capitalization.
Blank data is a catalog problem, not a design problem. Resolve a missing price, contradictory measurement, duplicate product, or unsupported promise in the catalog before you build anything. If the information isn’t available yet, let the product wait rather than filling the gap with plausible-sounding copy.
Next, organize products by the decisions shoppers make. “Gifts under €50” works if budget is a real shopping path; “Miscellaneous” rarely does. Keep category names concrete, don’t put near-identical products everywhere, and make sure each important category has enough purpose to deserve a page. The product and category planning guide has field checks and a complete example.
For the first pass, pick ten representative products across prices and priority categories, including one that is hard to photograph and one with detailed specifications. They expose weaknesses faster than ten nearly identical records.
3. Prepare the visual and verbal inputs
Gather the assets only the brand can supply or authorize: logo files, brand colors, the typeface you use, product images, any legitimate lifestyle or packaging images, and a short voice guide. Record who owns each file and where its use is licensed.
Product images should answer buying questions, not just decorate the page. A useful set shows the whole item, meaningful details, scale, packaging, and the product in use. Consistent framing makes categories easier to compare, but products that need different evidence can have different crops.
Keep originals and delivery-ready crops in a predictable folder structure with descriptive filenames. Check the assets on wide and narrow screens: text inside an image that works on desktop can become unreadable on a phone. The brand and product asset guide has an inventory, a rights check, and a shot list.
4. Turn the brief and catalog into a whole storefront
Now build the customer-facing store as one system, not a hero section with pages added later. Each surface has its own job:
| Surface | Job | First review question |
|---|---|---|
| Homepage | Explain the range and open the main shopping paths | Can a new visitor tell what is sold and where to start? |
| Category page | Help shoppers scan and compare a meaningful group | Are products grouped and presented consistently? |
| Product page | Support a decision with facts, media, price, and context | Are the important buying questions answered truthfully? |
| Header and footer | Provide orientation, navigation, and essential information | Can shoppers reach priority categories without guessing? |
| Cart | Confirm the intended purchase before checkout | Are products, quantities, subtotal, and the next action clear? |
| Checkout | Collect the information needed to complete the purchase | Can a shopper understand payment, delivery, tax, and errors? |
On most platforms this step means choosing a theme, adapting it to your catalog, and adding apps for what it lacks. In Setka, you give it the brief and the catalog, and it builds the homepage, category pages, product-page templates, header, footer, navigation, and cart from one store-wide direction. Product pages are filled with your actual product data, descriptions, and photos. The store runs inside the same platform as checkout and orders, so there is no theme code for you to maintain.
Check the first draft against the brief and your representative products. Does the hierarchy fit the audience? Does the brand feel specific? Is every claim grounded? Does unusual product data display clearly?
Then refine one page at a time. Open the page and describe the result you need, such as a quieter introduction, more emphasis on one category, or more prominent product facts; Setka uses the current page as the starting point. When you know the exact words, edit the copy directly. Preview every change before publishing. Each change creates a storefront-wide version you can branch from or return to. After a change, check the rest of the store as well: you still decide which direction is right.
5. Review the pages as a journey
Walk through realistic shopping tasks instead of approving pages one by one. Try it as a shopper who knows only the need, one who knows the category, and one who lands directly on a product page. Each should move forward without insider vocabulary.
On the homepage, look for a clear reason to buy and the main paths into the catalog. Use only real evidence: verified product qualities, delivery policies you actually operate, and brand facts you can support. Never invent reviews, customer counts, scarcity, or endorsements to fill a design.
On category pages, compare product cards for scannable names, prices, images, and deliberate ordering. On product pages, confirm that descriptions, specifications, images, price, and the buy button agree with the catalog. Then check the header, footer, mobile navigation, empty states, and cart.
6. Configure the commerce rules
A storefront is commercially usable only when everything after “add to cart” works. Set each area from real business decisions.
Cart and checkout
The cart should show products, quantities, and subtotal clearly and lead to checkout. At checkout, review customer details, address collection, delivery choices, payment, tax, confirmations, and error states. Checkout is a controlled transaction flow that has to record the purchase correctly; judge it on that before looks.
Payment
In Setka, you connect your business’s Stripe account in Settings → Payments, choose one store currency in Setka, enable payment methods in Stripe, and publish. A successful payment creates the paid order, updates inventory, sends the customer a confirmation, and notifies you. The Stripe setup guide walks through activation and merchant-issued refunds.
Shipping
Decide where you ship, what each destination costs, whether a threshold changes the price, and how exceptions are handled. In Setka, you set shipping rules in the admin: rates can depend on order value (not weight), and local pickup is available. Test addresses inside and outside your region. Word delivery options so a shopper understands the choice without decoding internal rate names.
Tax
Configure tax with rules that fit your business and products, based on your actual obligations rather than a guess. In Setka, you set tax by product type, then check how totals appear in each market you sell to.
7. Preview and test before publication
Treat preview as the point where you decide whether to publish. Run a short test set on desktop and mobile:
- Open the homepage and reach each priority category.
- Open representative products and compare displayed data with the catalog.
- Add, change, and remove cart items; check the empty cart.
- Go through every checkout field available before live payment.
- Try representative shipping destinations and review tax and totals.
Also check links, spelling, policy information, forms, narrow layouts, keyboard use, and obvious error messages.
8. Connect the domain and publish deliberately
Keep the store unpublished while critical tests fail. Once the preview passes, prepare the domain connection. Record the existing domain configuration first, identify any services already using the domain, and follow only the current values and verification steps Setka gives you for your store. DNS behavior varies, so don’t rely on copied values or an assumed propagation time.
After connection, repeat the essential checks on the real domain: secure loading, homepage and priority paths, cart, checkout entry, mobile layout, and both the root and www forms of the domain, which should behave as you set them in Setka. The domain and publishing guide has the connection sequence and a cutover checklist.
Publishing makes the store reachable and activates checkout; launch is when you start sending customers. In between, place a real order on your phone, confirm the paid Setka order, the inventory update, and the notifications, then refund it from the order. That works as a test because Setka runs checkout, orders, and refunds in one system.
Make publishing an explicit decision by one accountable person, and note which storefront version you approved and which tests passed. If a serious problem appears later, return to the last approved version and publish it.
9. Prepare for the first real order
Before launch, decide who reviews paid orders, checks items and addresses, packs, prepares shipment, and handles obvious exceptions. Limit customer data to the people who need it.
Run one order through that path and write down what happened. You should know where the paid order appears, which fulfillment details need checking, and what to do if an address, item, or shipping instruction is unclear. The first-order workflow guide is the focused runbook.
After launch, keep a small review routine: check critical paths, record problems customers report, review real order exceptions, and fix them in order of severity. For search visibility, use the new-store e-commerce SEO checklist to check crawl and index controls, page structure, internal links, images, and Search Console separately from the build.
A practical launch timeline
With ten complete products and your own images, phases 1–7 fit in one to two weeks. Producing assets, waiting on account reviews, or specialist configuration adds more.
| Phase | Main work | Exit condition |
|---|---|---|
| 1. Define | Offer, audience, proof, constraints, owner | The brief supports clear decisions |
| 2. Prepare | Catalog, categories, images, brand assets | Representative products are complete and checked |
| 3. Build | Whole-store draft and main shopping surfaces | The end-to-end structure exists |
| 4. Refine | Hierarchy, exact copy, page presentation, mobile | The storefront fits the brief and product data |
| 5. Configure | Payment, shipping, tax, checkout | Intended commercial cases are configured |
| 6. Test | Full purchase paths and order result | Critical cases pass and blockers are recorded |
| 7. Release | Domain connection, publish, live validation | The approved version works on the real domain |
| 8. Operate | First-order runbook and monitoring | The team can receive and handle an order |
Plan backward from the release date, and leave time for corrections, account reviews, domain work, and a few days without changes before publishing.
Worked sequence: a ten-product launch
Imagine a small ceramics brand launching four mug designs, three bowls, and three serving pieces. Here is how each decision becomes a checkpoint.
| Step | Merchant action | Store action | Checkpoint |
|---|---|---|---|
| Offer | Define “durable everyday ceramics for compact kitchens”; remove an unproven sustainability claim | — | Positioning uses evidence the brand can provide |
| Catalog | Complete ten names, prices, dimensions, care notes, identifiers, and availability | Products become the source for storefront content | Every displayed fact matches the catalog |
| Categories | Choose Mugs, Bowls, and Serving; assign each product once as its main group | Category surfaces reflect the three paths | A shopper can find each item from its expected path |
| Assets | Supply logo, palette, voice notes, and owned images with detail and scale views | Logo, palette, and voice notes shape the visual direction; the images fill product and merchandising slots | Crops remain useful on mobile and desktop |
| Draft | Approve the priority path from homepage to category to product | Generate the connected storefront | The result covers shared surfaces and cart, not only the homepage |
| Refine | Request a quieter homepage introduction; replace one headline with exact approved wording | Refine the current page and create the next version | Claims stay factual; the earlier version remains available |
| Commerce | Connect Stripe; set currency, methods, shipping, and tax | Checkout uses the configured settings | A successful checkout creates the correct paid order |
| Release | Approve preview, connect the domain with verified instructions, publish | Make the approved version live | Critical checks pass on the real domain |
| Operate | Process a paid order | Update the resulting order | The team can check customer and address data, pack accurately, and prepare shipment |
The table shows where Setka changes the work. The merchant supplies the facts and makes the judgments. Setka builds the connected storefront from the brief and catalog, handles page refinement and exact copy edits, and provides preview, publishing, and storefront-wide versions without handing over theme code to maintain. Setka takes on building the store and controlling its changes; the business decisions stay with the merchant.
What “ready to publish” means
The store is ready when its commercial decisions are explicit, its product data is trustworthy, its main shopping paths hold together, and its transactions have been tested. It also has a named owner for launch and order handling, a written list of known limitations, and an approved version you can return to.
AI can take most of the storefront assembly off your hands. It cannot decide whether a claim is true, a price works, a category matches how customers talk, a tax treatment is correct, an image is licensed, or a test result is acceptable. Those decisions stay yours.
Prepare ten representative products, then create your first store draft in Setka and check it against the sequence above.