Store Verification

Manage bookstore applications and verify the legitimacy of stores joining the BookWish marketplace.

Overview

Store verification ensures that only legitimate bookstores can sell on BookWish. While the current implementation may not have a formal verification queue, this guide outlines best practices for store management.

Store Account Types

BookWish has a bookstore user tier for store owners:

User tier set to bookstore
Can create and manage a Store record
Access to inventory management
Point-of-sale functionality
Can accept orders and payments

Verification Process

Application Review

When reviewing store applications:

Step 1: Business Verification

Verify business is legitimate
Check business registration/license
Confirm physical location (if applicable)
Verify business contact information

Step 2: Owner Verification

Confirm store owner identity
Verify email and phone
Check for multiple store attempts
Review any prior platform history

Step 3: Store Details

Review store name and description
Check for trademark conflicts
Verify address and location
Review store policies

Step 4: Financial Setup

Confirm payment processing setup
Verify bank account information
Check tax documentation
Review fee structure understanding

Approval Criteria

Approve When:

Business appears legitimate
Owner identity verified
Store details complete and accurate
Payment processing properly configured
No conflicts or concerns

Request More Information When:

Missing documentation
Unclear business model
Location doesn't match claims
Incomplete application

Reject When:

Fraudulent or fake business
Duplicate/ban evasion attempt
Fails to provide required documentation
Prior platform violations
Conflicts with platform policies

Managing Stores

Store Database Fields

Key fields in the Store model:

{
  id: string;
  ownerId: string;          // User ID (tier: bookstore)
  name: string;             // Store name
  slug: string;             // URL-friendly identifier
  description?: string;     // Store description
  logoUrl?: string;         // Store logo
  bannerUrl?: string;       // Store banner image

  // Location
  street?: string;
  city?: string;
  state?: string;
  zip?: string;
  country?: string;

  // Contact
  email?: string;
  phone?: string;
  website?: string;

  // Settings
  isActive: boolean;        // Store is active
  allowsPickup: boolean;    // Offers in-store pickup
  allowsShipping: boolean;  // Ships orders

  // Payment (Square integration)
  squareLocationId?: string;
  squareAccessToken?: string;  // Encrypted
  squareMerchantId?: string;

  // Custom domain
  customDomain?: string;
  customDomainVerified: boolean;

  // Timestamps
  createdAt: DateTime;
  updatedAt: DateTime;
}

Activating a Store

Enable Store:

UPDATE stores
SET is_active = true
WHERE id = 'store_id';

Grant Bookstore Tier:

UPDATE users
SET tier = 'bookstore'
WHERE id = 'owner_user_id';

Suspending a Store

Temporary Suspension:

UPDATE stores
SET is_active = false
WHERE id = 'store_id';

When to Suspend:

Policy violations
Customer complaints
Payment processing issues
Pending investigation
Store request (vacation mode)

Store Impact:

Inventory hidden from search
Orders not accepted
Store page shows inactive status
Owner can still access backend

Permanently Closing Store

Close Store:

-- Deactivate store
UPDATE stores
SET is_active = false
WHERE id = 'store_id';

-- Downgrade user tier
UPDATE users
SET tier = 'free'  -- or 'premium' if they had subscription
WHERE id = 'owner_user_id';

When to Close:

Owner request
Business closure
Repeated policy violations
Fraud or serious misconduct
Failed verification

Verification Checks

Business Legitimacy

Physical Stores:

Google Maps listing
Business license/registration
Physical address verification
Phone number validation
Website (if claimed)

Online Stores:

Domain ownership
Business registration
Tax documentation
Prior marketplace history
Social media presence

Red Flags

Watch For:

Temporary/disposable email
No business registration
Address doesn't match claimed location
No online presence
Too-good-to-be-true claims
Pressure to approve quickly
Missing documentation

Multiple Red Flags:

Request more information
Delay approval pending verification
Consult with team
May reject if unresolved

Identity Verification

Verify Owner:

Government-issued ID
Business ownership documents
Email confirmation
Phone verification
Video call (for high-risk cases)

Prevent Fraud:

Check against banned users
Look for duplicate attempts
Verify payment details
Review IP/device patterns

Store Quality Standards

Listing Requirements

Stores must maintain:

Accurate inventory
Fair pricing
Clear item conditions
Accurate descriptions
Timely fulfillment

Customer Service

Monitor for:

Order fulfillment rate
Response time to inquiries
Customer satisfaction
Return/refund handling
Communication quality

Policy Compliance

Stores must follow:

BookWish Terms of Service
Platform fee structure
Content guidelines
Prohibited items list
Privacy requirements

Monitoring Active Stores

Performance Metrics

Track for Each Store:

Total inventory items
Orders fulfilled
Average fulfillment time
Customer ratings (if implemented)
Revenue generated
Active status

Quality Issues

Warning Signs:

Multiple customer complaints
Consistently late fulfillment
High cancellation rate
Pricing violations
Content guideline violations

Progressive Actions:

Warning email
Performance improvement plan
Temporary suspension
Permanent closure

Regular Reviews

Monthly Store Review:

Check active store count
Review new applications
Monitor store performance
Address customer complaints
Update verification procedures

Payment Processing

Square Integration

BookWish integrates with Square for payments:

Stores connect Square accounts
Credentials stored encrypted
Location ID used for transactions
Merchant ID for identification

Verification Steps:

Store connects Square account
System verifies credentials
Test transaction (if required)
Enable payment processing
Monitor for issues

Payment Issues

Common Problems:

Invalid credentials
Expired tokens
Location misconfiguration
Account suspension (Square side)
Failed transactions

Resolution:

Contact store owner
Request credential refresh
Verify Square account status
Test payment flow
Document resolution

Custom Domains

Stores can use custom domains:

Domain ownership verified
DNS records configured
SSL certificate provisioned
Domain linked to store

Verification Process:

Store requests custom domain
System provides DNS records
Store updates DNS
System verifies configuration
Domain activated

Monitor:

Domain expiration
DNS configuration changes
SSL certificate renewal
Domain ownership changes

Communication with Stores

Approval Notification

When Approving:

Welcome email
Getting started guide
Link to store dashboard
Support contact information
Community guidelines

Rejection Notification

When Rejecting:

Clear explanation of reason
Reference specific requirements
Path to reapply (if applicable)
Support contact for questions
Professional and respectful tone

Suspension Notice

When Suspending:

Reason for suspension
Specific violations (if applicable)
Duration (if temporary)
Steps to resolve
Appeal process (if available)

Future Enhancements

Planned Features

Verification Queue:

Dedicated admin UI for applications
Application status tracking
Document upload and review
Automated checks (business lookup, etc.)

Store Analytics:

Performance dashboards
Customer satisfaction scores
Quality metrics
Automated warnings

Tiered Verification:

Express approval for established businesses
Enhanced verification for new stores
Periodic re-verification
Trusted seller programs

Database Queries

Find Unverified Stores

SELECT s.*, u.email as owner_email
FROM stores s
JOIN users u ON s.owner_id = u.id
WHERE s.is_active = false
  AND s.created_at >= NOW() - INTERVAL '30 days'
ORDER BY s.created_at DESC;

Find Inactive Stores

SELECT s.*,
  COUNT(DISTINCT i.id) as inventory_count,
  COUNT(DISTINCT o.id) as order_count
FROM stores s
LEFT JOIN inventory_items i ON s.id = i.store_id
LEFT JOIN orders o ON s.id = o.store_id
  AND o.created_at >= NOW() - INTERVAL '90 days'
WHERE s.is_active = true
GROUP BY s.id
HAVING COUNT(DISTINCT o.id) = 0
  AND s.created_at < NOW() - INTERVAL '90 days';

Find High-Performing Stores

SELECT s.*,
  COUNT(DISTINCT o.id) as total_orders,
  COUNT(DISTINCT i.id) as inventory_items
FROM stores s
LEFT JOIN orders o ON s.id = o.store_id
LEFT JOIN inventory_items i ON s.id = i.store_id
WHERE s.is_active = true
GROUP BY s.id
ORDER BY total_orders DESC
LIMIT 20;

Overview​

Store Account Types​

Verification Process​

Application Review​

Approval Criteria​

Managing Stores​

Store Database Fields​

Activating a Store​

Suspending a Store​

Permanently Closing Store​

Verification Checks​

Business Legitimacy​

Red Flags​

Identity Verification​

Store Quality Standards​

Listing Requirements​

Customer Service​

Policy Compliance​

Monitoring Active Stores​

Performance Metrics​

Quality Issues​

Regular Reviews​

Payment Processing​

Square Integration​

Payment Issues​

Custom Domains​

Communication with Stores​

Approval Notification​

Rejection Notification​

Suspension Notice​

Future Enhancements​

Planned Features​

Database Queries​

Find Unverified Stores​

Find Inactive Stores​

Find High-Performing Stores​

Next Steps​