Top 5 Micro-SaaS Ideas for Developers with Minimal Startup Costs to Minimize Server Costs and Load Overhead
1. Real-time Inventory Sync for E-commerce Platforms
Many e-commerce businesses struggle with maintaining accurate inventory levels across multiple sales channels (Shopify, WooCommerce, Amazon, eBay, etc.). A common pain point is overselling or underselling due to synchronization delays. A micro-SaaS solution that provides near real-time, bidirectional inventory synchronization can be incredibly valuable. The core challenge here is efficient API interaction and robust error handling.
Technical Stack Considerations:
- Backend Language: Python (with FastAPI for performance) or Node.js (with Express). These are excellent for I/O-bound tasks like API calls.
- Database: PostgreSQL or Redis. Redis is ideal for caching frequently accessed inventory counts and for managing queues. PostgreSQL for persistent storage of sync logs and configuration.
- Queueing System: RabbitMQ or Kafka for handling asynchronous updates and retries.
- Deployment: Docker containers on a cost-effective cloud provider like DigitalOcean App Platform, Render, or AWS Fargate.
Core Logic – Python Example (Simplified):
This snippet illustrates a simplified webhook handler for a platform like Shopify, which would then trigger an update to other channels via their respective APIs. In a production system, this would be part of a larger asynchronous worker process.
import requests
import json
from datetime import datetime
# Assume these are configured and securely stored
PLATFORM_API_KEYS = {
"shopify": "your_shopify_api_key",
"woocommerce": "your_woocommerce_api_key",
"amazon": "your_amazon_api_key"
}
PLATFORM_API_ENDPOINTS = {
"shopify": "https://your-store.myshopify.com/admin/api/2023-10/products.json",
"woocommerce": "https://your-store.com/wp-json/wc/v3/products",
"amazon": "https://sellingpartnerapi-na.amazon.com/catalog/v0/items" # Example, actual endpoint varies
}
def get_product_inventory(platform, product_id):
"""Fetches inventory for a given product from a platform."""
api_key = PLATFORM_API_KEYS.get(platform)
endpoint = PLATFORM_API_ENDPOINTS.get(platform)
if not api_key or not endpoint:
return None
headers = {"X-Shopify-Access-Token": api_key} if platform == "shopify" else {} # Example headers
params = {} # Add platform-specific params
try:
if platform == "shopify":
# Shopify API for inventory levels is more complex, often involving variants
# This is a placeholder for fetching product data, inventory would be a separate call
response = requests.get(f"https://your-store.myshopify.com/admin/api/2023-10/products/{product_id}.json", headers=headers)
response.raise_for_status()
product_data = response.json()
# Logic to extract inventory from variants would go here
return {"total_inventory": 100} # Placeholder
elif platform == "woocommerce":
response = requests.get(f"{endpoint}/{product_id}", headers={"Authorization": f"Basic {api_key}"}) # Basic Auth example
response.raise_for_status()
product_data = response.json()
return {"total_inventory": product_data.get("stock_quantity", 0)}
# Add logic for other platforms
return None
except requests.exceptions.RequestException as e:
print(f"Error fetching inventory from {platform} for product {product_id}: {e}")
return None
def update_product_inventory(platform, product_id, new_quantity):
"""Updates inventory for a given product on a platform."""
api_key = PLATFORM_API_KEYS.get(platform)
endpoint = PLATFORM_API_ENDPOINTS.get(platform)
if not api_key or not endpoint:
return False
headers = {"X-Shopify-Access-Token": api_key} if platform == "shopify" else {}
payload = {}
try:
if platform == "shopify":
# Shopify inventory updates are complex, often requiring inventory item and location IDs
# This is a highly simplified placeholder
inventory_level_url = f"https://your-store.myshopify.com/admin/api/2023-10/inventory_levels/set.json"
# You'd need to find the correct inventory_item_id and location_id
payload = {
"inventory_level": {
"inventory_item_id": "YOUR_INVENTORY_ITEM_ID",
"location_id": "YOUR_LOCATION_ID",
"available": new_quantity
}
}
response = requests.post(inventory_level_url, headers=headers, json=payload)
response.raise_for_status()
print(f"Updated Shopify inventory for {product_id} to {new_quantity}")
return True
elif platform == "woocommerce":
payload = {"stock_quantity": new_quantity}
response = requests.put(f"{endpoint}/{product_id}", headers={"Authorization": f"Basic {api_key}"}, json=payload)
response.raise_for_status()
print(f"Updated WooCommerce inventory for {product_id} to {new_quantity}")
return True
# Add logic for other platforms
return False
except requests.exceptions.RequestException as e:
print(f"Error updating inventory on {platform} for product {product_id}: {e}")
return False
def handle_inventory_update_event(event_data):
"""Processes an incoming inventory update event (e.g., from a webhook)."""
# event_data would contain platform, product_id, and new_quantity
platform = event_data.get("platform")
product_id = event_data.get("product_id")
new_quantity = event_data.get("new_quantity")
if not all([platform, product_id, new_quantity is not None]):
print("Invalid event data received.")
return
print(f"Received update for {platform} product {product_id} to {new_quantity}")
# In a real system, this would be enqueued for processing by a worker
# For simplicity, we'll call directly here.
# Update other platforms
for target_platform in PLATFORM_API_KEYS.keys():
if target_platform != platform:
success = update_product_inventory(target_platform, product_id, new_quantity)
if not success:
print(f"Failed to update {target_platform} for product {product_id}.")
# Implement retry logic or error reporting here
# Example usage (simulating a webhook payload)
# webhook_payload = {
# "platform": "shopify",
# "product_id": "1234567890",
# "new_quantity": 50
# }
# handle_inventory_update_event(webhook_payload)
Minimizing Server Costs & Load:
- Event-Driven Architecture: Rely on webhooks from e-commerce platforms. Your service only wakes up when an event occurs, rather than constantly polling.
- Asynchronous Processing: Use message queues (RabbitMQ, SQS) to decouple webhook reception from actual API calls. This smooths out load spikes and allows for retries.
- Serverless Functions: For webhook reception and simple event processing, AWS Lambda, Google Cloud Functions, or Azure Functions can be extremely cost-effective, scaling to zero when idle.
- Efficient API Usage: Batch updates where possible. Understand rate limits of each platform’s API and implement backoff strategies.
- Caching: Use Redis to cache frequently accessed product data or inventory counts to reduce redundant API calls.
2. Automated Product Data Enrichment & Categorization
E-commerce sellers often have product descriptions, titles, and images that are SEO-unfriendly, lack detail, or are inconsistently categorized. A micro-SaaS that leverages AI/ML to automatically enrich product data (e.g., generate better descriptions, extract attributes, suggest categories) can significantly improve product discoverability and conversion rates.
Technical Stack Considerations:
- Backend: Python (excellent for AI/ML libraries).
- AI/ML: Libraries like spaCy, NLTK for NLP tasks. For more advanced generation, integrate with OpenAI API, Cohere, or host open-source models (e.g., via Hugging Face).
- Image Processing: Pillow (Python Imaging Library) for basic manipulation, potentially cloud vision APIs (Google Vision AI, AWS Rekognition) for feature extraction.
- Database: PostgreSQL for storing original and enriched data, potentially a vector database (e.g., Pinecone, Weaviate) if implementing similarity search for product recommendations.
- Deployment: Similar to the inventory sync, focus on cost-effective, scalable options.
Core Logic – Python Example (Simplified Text Enrichment):
import requests
import json
import os
# Using OpenAI API as an example for text generation
OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
OPENAI_API_URL = "https://api.openai.com/v1/chat/completions"
def enrich_product_description(original_description, product_title, target_audience="online shoppers"):
"""Uses AI to generate a more engaging product description."""
if not OPENAI_API_KEY:
return "API key not configured."
prompt = f"""
You are an expert e-commerce copywriter. Rewrite the following product description to be more engaging, SEO-friendly, and persuasive for {target_audience}.
Focus on benefits and key features. Keep it concise but informative.
Product Title: {product_title}
Original Description: {original_description}
Rewritten Description:
"""
headers = {
"Authorization": f"Bearer {OPENAI_API_KEY}",
"Content-Type": "application/json"
}
payload = {
"model": "gpt-3.5-turbo", # Or gpt-4 for better quality
"messages": [{"role": "user", "content": prompt}],
"max_tokens": 150,
"temperature": 0.7,
}
try:
response = requests.post(OPENAI_API_URL, headers=headers, json=payload)
response.raise_for_status()
result = response.json()
return result['choices'][0]['message']['content'].strip()
except requests.exceptions.RequestException as e:
print(f"Error calling OpenAI API: {e}")
return f"Error enriching description: {e}"
def categorize_product(product_title, product_description):
"""Suggests a category for a product using AI."""
if not OPENAI_API_KEY:
return "API key not configured."
prompt = f"""
Given the product title and description, suggest the most appropriate category from the following list:
[Electronics, Clothing, Home & Garden, Books, Toys, Sports & Outdoors, Health & Beauty, Automotive]
Provide only the category name.
Product Title: {product_title}
Product Description: {product_description}
Suggested Category:
"""
headers = {
"Authorization": f"Bearer {OPENAI_API_KEY}",
"Content-Type": "application/json"
}
payload = {
"model": "gpt-3.5-turbo",
"messages": [{"role": "user", "content": prompt}],
"max_tokens": 20,
"temperature": 0.2, # Lower temperature for more deterministic output
}
try:
response = requests.post(OPENAI_API_URL, headers=headers, json=payload)
response.raise_for_status()
result = response.json()
category = result['choices'][0]['message']['content'].strip()
# Basic validation
valid_categories = ["Electronics", "Clothing", "Home & Garden", "Books", "Toys", "Sports & Outdoors", "Health & Beauty", "Automotive"]
if category in valid_categories:
return category
else:
return "Uncategorized"
except requests.exceptions.RequestException as e:
print(f"Error calling OpenAI API for categorization: {e}")
return f"Error categorizing product: {e}"
# Example usage
# product_info = {
# "title": "Wireless Bluetooth Earbuds with Noise Cancellation",
# "description": "High-fidelity sound, long battery life, comfortable fit. Perfect for workouts and daily commutes."
# }
#
# enriched_desc = enrich_product_description(product_info["description"], product_info["title"])
# suggested_cat = categorize_product(product_info["title"], product_info["description"])
#
# print(f"Enriched Description: {enriched_desc}")
# print(f"Suggested Category: {suggested_cat}")
Minimizing Server Costs & Load:
- Leverage External AI APIs: Services like OpenAI, Cohere, or Google AI Platform offer powerful models without the need to manage GPU infrastructure. Pay-per-use models are cost-effective for low-volume services.
- Batch Processing: If enriching many products, queue requests and process them in batches to optimize API calls and reduce overhead.
- Caching Results: Cache enriched descriptions and categories for identical or very similar inputs to avoid redundant AI processing.
- Model Selection: Use the smallest, fastest AI model that meets your quality requirements. GPT-3.5-turbo is significantly cheaper and faster than GPT-4.
- Image Analysis: Offload image analysis to specialized cloud services rather than building complex CV pipelines yourself.
3. Automated Review Management & Response Generation
Managing customer reviews across multiple platforms (e-commerce site, Google My Business, social media) is time-consuming. A micro-SaaS that aggregates reviews, identifies sentiment, and generates draft responses can save significant time and improve customer engagement.
Technical Stack Considerations:
- Backend: Python or Node.js.
- Review Aggregation: APIs for platforms like Shopify, WooCommerce, Google My Business, Trustpilot, etc. Web scraping might be necessary for platforms without robust APIs (use ethically and check ToS).
- Sentiment Analysis: Libraries like VADER (Valence Aware Dictionary and sEntiment Reasoner) for Python, or cloud NLP services.
- Response Generation: Similar to product enrichment, leverage LLMs (OpenAI, Cohere) for drafting responses.
- Database: PostgreSQL for storing reviews, sentiment scores, and response history.
- Deployment: Cost-effective cloud hosting.
Core Logic – Python Example (Sentiment Analysis & Response Draft):
import requests
import json
import os
from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
# Assume OPENAI_API_KEY and related functions are defined as in previous example
def analyze_review_sentiment(text):
"""Analyzes sentiment using VADER."""
analyzer = SentimentIntensityAnalyzer()
vs = analyzer.polarity_scores(text)
# vs is a dict: {'neg': 0.0, 'neu': 0.323, 'pos': 0.677, 'compound': 0.934}
if vs['compound'] >= 0.05:
return "positive"
elif vs['compound'] <= -0.05:
return "negative"
else:
return "neutral"
def draft_review_response(review_text, sentiment, product_name=None, platform="Your Store"):
"""Generates a draft response using an LLM."""
if not OPENAI_API_KEY:
return "API key not configured."
if sentiment == "positive":
prompt = f"""
A customer left a positive review for a product on {platform}.
Review: "{review_text}"
{f"Product: {product_name}" if product_name else ""}
Draft a short, appreciative, and genuine response. Thank them for their feedback.
Response:
"""
elif sentiment == "negative":
prompt = f"""
A customer left a negative review for a product on {platform}.
Review: "{review_text}"
{f"Product: {product_name}" if product_name else ""}
Draft a professional, empathetic, and constructive response. Acknowledge their issue and offer to help resolve it offline. Do NOT make excuses.
Response:
"""
else: # neutral
prompt = f"""
A customer left a neutral review for a product on {platform}.
Review: "{review_text}"
{f"Product: {product_name}" if product_name else ""}
Draft a polite and brief response acknowledging their feedback.
Response:
"""
headers = {
"Authorization": f"Bearer {OPENAI_API_KEY}",
"Content-Type": "application/json"
}
payload = {
"model": "gpt-3.5-turbo",
"messages": [{"role": "user", "content": prompt}],
"max_tokens": 100,
"temperature": 0.6,
}
try:
response = requests.post(OPENAI_API_URL, headers=headers, json=payload)
response.raise_for_status()
result = response.json()
return result['choices'][0]['message']['content'].strip()
except requests.exceptions.RequestException as e:
print(f"Error calling OpenAI API for response generation: {e}")
return f"Error drafting response: {e}"
# Example usage
# customer_review = "The battery life is amazing, and the sound quality is top-notch! Highly recommend."
# product = "Wireless Earbuds X1"
#
# sentiment = analyze_review_sentiment(customer_review)
# response_draft = draft_review_response(customer_review, sentiment, product)
#
# print(f"Sentiment: {sentiment}")
# print(f"Draft Response:\n{response_draft}")
Minimizing Server Costs & Load:
- API Integration: Prioritize platforms with official APIs. Web scraping is resource-intensive and brittle.
- Efficient Sentiment Analysis: VADER is a lightweight, rule-based library suitable for many cases. Cloud NLP services offer higher accuracy but at a cost. Choose based on need.
- LLM Prompt Engineering: Craft concise prompts for LLMs to minimize token usage and processing time.
- Asynchronous Processing: Fetch reviews in batches and process sentiment/response generation asynchronously using queues.
- Rate Limiting: Be mindful of API rate limits for fetching reviews and for posting responses (if automated).
4. Dynamic Pricing & Promotion Engine
Manually adjusting prices based on demand, competitor pricing, or inventory levels is inefficient. A micro-SaaS that automates this process, or helps manage complex promotions (e.g., BOGO, tiered discounts), can directly impact revenue. This requires careful integration with e-commerce platforms and potentially external data sources.
Technical Stack Considerations:
- Backend: Python (for data analysis and potential ML) or Go (for high concurrency).
- Data Storage: PostgreSQL for product data, pricing rules, and historical pricing. Redis for caching current prices and competitor data.
- Pricing Logic: Can range from simple rule-based systems to complex ML models predicting optimal prices.
- Competitor Data: May involve web scraping (again, ethically and legally) or using third-party pricing intelligence APIs.
- E-commerce Integration: APIs for Shopify, WooCommerce, etc., to push price updates.
- Deployment: Scalable cloud infrastructure. Consider compute instances that can handle data processing bursts.
Core Logic – Python Example (Simple Rule-Based Pricing):
import requests
import json
import time
# Assume platform API interaction functions (get_product_price, update_product_price) exist
def get_competitor_price(product_sku, competitor_url):
"""Placeholder for fetching competitor price (e.g., via scraping or API)."""
# In a real scenario, this would involve robust scraping or a dedicated service.
# For demonstration, simulate a price.
print(f"Fetching competitor price for {product_sku} from {competitor_url}...")
time.sleep(1) # Simulate network latency
# Simulate price fluctuation
simulated_prices = {
"SKU123": [19.99, 20.50, 18.75],
"SKU456": [49.99, 51.00, 48.50]
}
prices = simulated_prices.get(product_sku, [25.00])
return prices[int(time.time()) % len(prices)] # Cycle through prices
def calculate_dynamic_price(product_data, competitor_prices, inventory_level):
"""Calculates a dynamic price based on rules."""
base_price = product_data['base_price']
min_price = product_data['min_price']
max_price = product_data['max_price']
sku = product_data['sku']
# Rule 1: If inventory is low, increase price slightly (e.g., > 20% margin)
if inventory_level < 10:
price = base_price * 1.15
# Rule 2: If competitor price is significantly lower, match or beat it (within bounds)
elif sku in competitor_prices and competitor_prices[sku] < base_price * 0.9:
price = max(min_price, competitor_prices[sku] - 0.50) # Beat by $0.50
# Rule 3: Standard pricing, maybe a small adjustment based on demand signal (e.g., recent sales velocity)
else:
price = base_price
# Ensure price stays within min/max bounds
final_price = max(min_price, min(max_price, price))
return round(final_price, 2)
def manage_pricing(product_id, platform_config):
"""Orchestrates fetching data and updating price."""
# 1. Fetch product details, current price, inventory from platform
# current_product_data = get_product_details(platform_config['api_key'], product_id)
# current_inventory = get_product_inventory(platform_config['api_key'], product_id)
# Example data:
current_product_data = {
"id": product_id,
"sku": "SKU123",
"base_price": 22.00,
"min_price": 15.00,
"max_price": 30.00
}
current_inventory = 15 # Example
# 2. Fetch competitor prices for this product's SKU
competitor_prices = {}
for competitor in platform_config.get('competitors', []):
comp_price = get_competitor_price(current_product_data['sku'], competitor['url'])
competitor_prices[current_product_data['sku']] = comp_price
# 3. Calculate the new price
new_price = calculate_dynamic_price(current_product_data, competitor_prices, current_inventory)
# 4. If price has changed significantly, update on the platform
# current_platform_price = get_product_price(platform_config['api_key'], product_id)
current_platform_price = 22.00 # Example
if abs(new_price - current_platform_price) > 0.10: # Only update if change is > $0.10
print(f"Updating price for {product_id} from {current_platform_price} to {new_price}")
# update_product_price(platform_config['api_key'], product_id, new_price)
else:
print(f"Price for {product_id} remains {current_platform_price} (calculated: {new_price}). No update needed.")
# Example configuration
# shopify_config = {
# "api_key": "YOUR_SHOPIFY_KEY",
# "competitors": [
# {"name": "CompetitorA", "url": "http://competitor-a.com/product/SKU123"},
# {"name": "CompetitorB", "url": "http://competitor-b.com/product/SKU123"}
# ]
# }
#
# manage_pricing("PRODUCT_ID_1", shopify_config)
Minimizing Server Costs & Load:
- Targeted Data Fetching: Only fetch competitor data or inventory levels when necessary, not on a fixed, high-frequency schedule for all products.
- Efficient Scraping: If scraping is used, implement aggressive caching, user-agent rotation, and respect `robots.txt`. Use headless browsers (like Puppeteer/Playwright) judiciously as they are resource-intensive.
- Rule Engine Optimization: Keep pricing rules as simple as possible. Complex decision trees or ML models require more compute.
- Batch Updates: Push price updates to e-commerce platforms in batches if their APIs support it.
- Serverless for Triggers: Use serverless functions triggered by events (e.g., inventory level change alerts) to initiate pricing recalculations, rather than a constantly running service.
5. Automated Order Routing & Fulfillment Optimization
For businesses selling through multiple channels or with multiple warehouses/fulfillment centers, efficiently routing orders to the best location for fulfillment is critical. This micro-SaaS can analyze order details, inventory availability across locations, shipping costs, and delivery times to determine the optimal fulfillment point.
Technical Stack Considerations:
- Backend: Python or Go.
- Data Storage: PostgreSQL for order data, inventory levels per location, warehouse/fulfillment center details, shipping rates.
- Inventory Management: Real-time (or near real-time) access to inventory levels across all locations.
- Shipping Rate APIs: Integration with carriers (UPS, FedEx, USPS) or multi-carrier shipping platforms (Shippo, EasyPost) to get real-time rates and estimated delivery times.
- Mapping/Geocoding: Services like Google Maps API or OpenStreetMap for calculating distances and transit times.
- Deployment: Cloud infrastructure capable of handling potentially complex calculations and external API calls.
Core Logic – Python Example (Simplified Routing Decision):
import requests
import json
import datetime
# Assume functions to get inventory, shipping rates, and order details exist
def get_shipping_cost_and_time(origin_zip, dest_zip, package_dims, carrier_api_key):
"""Placeholder for getting shipping cost and estimated delivery time."""
# This would integrate with Shippo, EasyPost, or direct carrier APIs.
# Returns a tuple: (cost, estimated_days)
print(f"Calculating shipping from {origin_zip} to {dest_zip}...")
# Simulate results
distance = abs(int(origin_zip[:3]) - int(dest_zip[:3])) # Very rough distance proxy
simulated_cost = 5.00 + (distance * 0.1) + (package_dims['weight'] * 0.5)
simulated_days = max(1, distance // 100) # Rough estimate
return (round(simulated_cost, 2), simulated_days)
def find_optimal_fulfillment_location(order, inventory_data, warehouse_locations, shipping_api_config):
"""Determines the best warehouse to fulfill an order from."""
order_items = order['items']
destination_address = order['shipping_address']
destination_zip = destination_address['zip_code']
best_option = None
min_total_cost = float('inf')
min_delivery_time = float('inf')
for warehouse in warehouse_locations:
warehouse_zip = warehouse['zip_code']
warehouse_inventory = inventory_data.get(warehouse['id'], {})
# Check if warehouse has all items in stock
has_stock = True
total_weight = 0
total_volume = 0 # Simplified
for item in order_items:
sku = item['sku']
quantity = item['quantity']
if warehouse_inventory.get(sku, 0) < quantity:
has_stock = False
break
# Assume item data includes weight/dimensions for calculation
total_weight += item.get('weight', 1) * quantity
total_volume += item.get('volume', 1) * quantity # Simplified
if not has_stock:
continue
# Calculate shipping cost and time from this warehouse
package_dims = {'weight': total_weight, 'volume': total_volume} # Simplified
try:
shipping_cost, estimated_days = get_shipping_cost_and_time(
warehouse_zip,
destination_zip,
package_dims,
shipping_api_config['key']
)
# Consider warehouse handling cost if applicable
handling_cost = warehouse.get('handling_fee', 1.00)
total_cost = shipping_cost + handling_cost
# Decision logic: Prioritize lowest cost, then fastest delivery
if total_cost < min_total_cost:
min_total_cost = total_cost
min_delivery_time = estimated_days
best_option = {
"warehouse_id": warehouse['id'],
"cost": total_cost,
"delivery_days": estimated_days,
"shipping_cost": shipping_cost,
"handling_cost": handling_cost
}
elif total_cost == min_total_cost and estimated_days < min_delivery_time:
min_delivery_time = estimated_days
best_option = {
"warehouse_id": warehouse['id'],
"cost": total_cost,
"delivery_days": estimated_days,
"shipping_cost": shipping_cost,
"handling_cost": handling_cost
}
except Exception as e:
print(f"Error calculating shipping for warehouse {warehouse['id']}: {e}")
continue
return best_option
# Example Data Structures
# order_data = {
# "id": "ORD98765",
# "items": [
# {"sku": "SKU123", "quantity": 2, "weight": 0.5, "volume": 100},
# {"sku": "SKU456", "quantity": 1, "weight": 2.0, "volume": 500}
# ],
# "shipping_address": {"zip_code": "90210", "country": "US"}
# }
#
# current_inventory = {
# "WH1": {"SKU123": 10, "SKU456": 5}, # Warehouse 1 inventory
# "WH2": {"SKU123": 5, "SKU456": 8} # Warehouse 2 inventory
# }
#
# warehouses = [
# {"id": "WH1", "zip_code": "10001", "handling_fee": 1.00},
# {"id": "WH2", "zip_code": "90001", "handling_fee": 1.20}
# ]
#
# shipping_config = {"key": "YOUR_SHIPPING_API_KEY"}
#
# optimal_location = find_optimal_fulfillment_location(order_data, current_inventory, warehouses, shipping_config)
#
# if optimal_location:
# print(f"Optimal Fulfillment Location: Warehouse {optimal_location['warehouse_id']}")
# print(f"Estimated Cost: ${optimal_location['cost']:.2f}")
# print(f"Estimated Delivery Time: {optimal_location['delivery_days']} days")
# else:
# print("Could not find a suitable