Top 10 Developer Tooling and Productivity SaaS Ideas to Launch in 2026 without Relying on Paid Advertising Budgets
1. AI-Powered Code Review & Refactoring Assistant
Leveraging LLMs for automated code quality checks and refactoring suggestions is a massive opportunity. Focus on niche languages or frameworks where existing tools are lacking or overly expensive. The key is to provide actionable, context-aware recommendations that go beyond simple linting.
Consider a SaaS that integrates with Git repositories (GitHub, GitLab, Bitbucket) and analyzes pull requests. It should identify potential bugs, security vulnerabilities, performance bottlenecks, and suggest idiomatic improvements. For monetization, offer tiered plans based on repository size, number of users, and advanced features like custom rule sets or integration with CI/CD pipelines.
Core Functionality & Integration Example (Python/Flask)
The backend could be built using Python with Flask, interacting with a large language model API (e.g., OpenAI’s GPT-4 or a fine-tuned open-source model). The Git integration would use webhooks to trigger analysis upon new commits or pull request events.
from flask import Flask, request, jsonify
import openai
import os
app = Flask(__name__)
openai.api_key = os.environ.get("OPENAI_API_KEY")
def analyze_code_snippet(code_snippet):
prompt = f"""
Analyze the following Python code snippet for potential bugs, security vulnerabilities, performance issues, and suggest idiomatic improvements.
Provide specific line numbers and clear explanations for each suggestion.
Code:
```python
{code_snippet}
```
Analysis:
"""
try:
response = openai.ChatCompletion.create(
model="gpt-4", # Or a more cost-effective model
messages=[
{"role": "system", "content": "You are an expert Python code reviewer."},
{"role": "user", "content": prompt}
],
max_tokens=500,
temperature=0.5,
)
return response.choices[0].message['content'].strip()
except Exception as e:
return f"Error during AI analysis: {e}"
@app.route('/webhook/github', methods=['POST'])
def github_webhook():
payload = request.json
if request.headers.get('X-GitHub-Event') == 'pull_request':
action = payload.get('action')
if action in ['opened', 'synchronize']:
pull_request = payload.get('pull_request')
repo_name = pull_request['head']['repo']['full_name']
pr_number = pull_request['number']
# In a real app, you'd fetch the diff here using GitHub API
# For demonstration, let's assume we have a snippet
# This part requires significant implementation for diff parsing
# Example: Fetching files changed and their content
# For simplicity, let's pretend we got a snippet from a file
# In reality, you'd iterate through changed files and their content
sample_code_to_analyze = """
def calculate_total(price, quantity):
# Potential issue: integer overflow if price * quantity is very large
total = price * quantity
# Missing input validation: price and quantity could be negative
return total
class User:
def __init__(self, username, password):
self.username = username
# Storing passwords in plain text is a major security risk
self.password = password
def authenticate(self, password_attempt):
return self.password == password_attempt
"""
analysis_results = analyze_code_snippet(sample_code_to_analyze)
# In a real app, you'd post these results back to the PR as comments
print(f"Analysis for PR #{pr_number} in {repo_name}:\n{analysis_results}")
return jsonify({"status": "analysis_triggered", "pr": pr_number}), 200
return jsonify({"message": "Event not processed"}), 400
if __name__ == '__main__':
# For local testing, use ngrok to expose this endpoint
# python -m flask run --host=0.0.0.0 --port=5000
app.run(debug=True, port=5000)
2. Automated Performance Testing & Bottleneck Identification for E-commerce
E-commerce sites live and die by their performance. A SaaS that automates load testing, identifies slow database queries, inefficient API calls, and front-end rendering issues is invaluable. Focus on generating realistic user traffic patterns specific to e-commerce (browsing, adding to cart, checkout).
Monetization could be based on the number of tests run per month, the duration of tests, the number of concurrent users simulated, and detailed reporting features. Offer integrations with APM (Application Performance Monitoring) tools like Datadog or New Relic.
Load Testing & Analysis Workflow (Bash/Locust)
Locust is an open-source load testing tool written in Python. You can script user behavior and run distributed load tests. The SaaS would provide a managed environment for running these tests and a dashboard for visualizing results.
# 1. Define user behavior in a Python file (e.g., locustfile.py)
# Example locustfile.py for an e-commerce site:
#
# from locust import HttpUser, task, between
#
# class EcommerceUser(HttpUser):
# wait_time = between(1, 5) # seconds
#
# @task(10) # Higher weight for browsing
# def browse_products(self):
# self.client.get("/products")
# product_id = "12345" # Example product ID
# self.client.get(f"/products/{product_id}")
#
# @task(5)
# def add_to_cart(self):
# self.client.post("/cart/add", json={"product_id": "67890", "quantity": 1})
#
# @task(1) # Lower weight for checkout
# def checkout(self):
# self.client.post("/checkout/start")
#
# def on_start(self):
# # Login or set session cookies if needed
# self.client.post("/login", json={"username": "testuser", "password": "password"})
# 2. Install Locust
# pip install locust
# 3. Run Locust locally for testing
# locust -f locustfile.py --host=https://your-ecommerce-site.com
# 4. SaaS backend would orchestrate distributed runs using Locust's master/worker mode
# Master command:
# locust -f locustfile.py --master --web-host=0.0.0.0
# Worker command (run on multiple machines/containers):
# locust -f locustfile.py --worker --master-host=your-master-ip
# 5. The SaaS would collect results (e.g., via Locust's REST API or custom listeners)
# and present them in a dashboard.
# Example of fetching stats via API (Python requests):
# import requests
# response = requests.get("http://localhost:8089/stats/requests")
# print(response.json())
3. Real-time Inventory Synchronization & Anomaly Detection
For e-commerce businesses with multiple sales channels (own website, marketplaces like Amazon/eBay, physical stores), maintaining accurate, real-time inventory is critical. A SaaS that reliably syncs inventory across all platforms and flags discrepancies or potential stockouts before they happen offers immense value.
Monetization could be per-channel integration, per-SKU volume, or a flat monthly fee with tiers. Advanced features like predictive stock level recommendations or automated reordering triggers would justify higher pricing.
Data Synchronization Logic (Node.js/Express)
This requires robust API integrations with various platforms. A common pattern involves webhooks for real-time updates and scheduled polling for platforms that don’t support webhooks. Anomaly detection can be rule-based or use simple statistical methods.
// Simplified example using hypothetical APIs
const express = require('express');
const axios = require('axios');
const app = express();
app.use(express.json());
const INVENTORY_DB = { // In-memory for demo, use a real DB
"SKU123": { quantity: 100, channels: { "own_site": 50, "amazon": 50 } },
"SKU456": { quantity: 50, channels: { "own_site": 25, "ebay": 25 } }
};
const CHANNEL_APIS = {
"own_site": { updateUrl: "https://api.yoursite.com/inventory/update" },
"amazon": { updateUrl: "https://api.amazon.com/inventory/update" },
"ebay": { updateUrl: "https://api.ebay.com/inventory/update" }
};
// Webhook endpoint for 'own_site' updates
app.post('/webhook/own_site', async (req, res) => {
const { sku, quantity_change } = req.body;
if (INVENTORY_DB[sku]) {
INVENTORY_DB[sku].quantity += quantity_change;
INVENTORY_DB[sku].channels.own_site = INVENTORY_DB[sku].quantity; // Simplified sync
await syncToOtherChannels(sku, INVENTORY_DB[sku].quantity);
console.log(`Own site update for ${sku}: New total ${INVENTORY_DB[sku].quantity}`);
// Add anomaly detection logic here (e.g., if quantity drops below threshold)
detectAnomalies(sku, INVENTORY_DB[sku].quantity);
}
res.sendStatus(200);
});
async function syncToOtherChannels(sku, newQuantity) {
for (const channel in CHANNEL_APIS) {
if (channel !== "own_site") { // Don't sync back to the source
try {
// Simulate updating other channels
// In reality, this would involve complex API calls and error handling
console.log(`Syncing ${sku} to ${channel}: ${newQuantity}`);
// await axios.post(CHANNEL_APIS[channel].updateUrl, { sku, quantity: newQuantity });
INVENTORY_DB[sku].channels[channel] = newQuantity; // Demo update
} catch (error) {
console.error(`Failed to sync ${sku} to ${channel}:`, error.message);
// Trigger alerts or manual review
}
}
}
}
function detectAnomalies(sku, currentQuantity) {
// Simple anomaly detection: Stock below 10 units
if (currentQuantity < 10) {
console.warn(`ALERT: Low stock for ${sku}! Current quantity: ${currentQuantity}`);
// Trigger notification service
}
// More advanced: Compare against historical sales data, predict stockouts
}
// Scheduled job to poll channels without webhooks (e.g., every 15 minutes)
// setInterval(() => {
// console.log("Running scheduled inventory check...");
// // Logic to poll Amazon, eBay etc. and compare with INVENTORY_DB
// }, 15 * 60 * 1000);
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => console.log(`Inventory sync service running on port ${PORT}`));
4. Automated A/B Testing & Conversion Rate Optimization (CRO) Platform
While tools like Google Optimize exist, a more integrated and developer-centric platform for e-commerce CRO can be built. This SaaS would simplify the creation, deployment, and analysis of A/B tests for landing pages, product pages, checkout flows, and email campaigns. Focus on seamless integration with popular e-commerce platforms (Shopify, WooCommerce) and analytics tools.
Monetization could be based on the number of active tests, traffic volume, or advanced statistical analysis features (e.g., multi-variate testing, Bayesian analysis). Offer pre-built templates for common e-commerce tests.
JavaScript Snippet for Client-Side A/B Testing
The core of a client-side A/B testing tool is a JavaScript snippet that loads asynchronously, determines the user’s assigned variation, and modifies the DOM accordingly. Results are then sent back to a central analytics server.
// Example client-side A/B testing script (to be embedded on the e-commerce site)
(function() {
const TEST_ID = 'hero-banner-headline';
const VARIATIONS = ['control', 'variation_a', 'variation_b']; // 'control' is original
const API_ENDPOINT = 'https://your-ab-test-saas.com/api/v1/track'; // Your SaaS endpoint
function getCookie(name) {
const value = `; ${document.cookie}`;
const parts = value.split(`; ${name}=`);
if (parts.length === 2) return parts.pop().split(';').shift();
return null;
}
function setCookie(name, value, days) {
const date = new Date();
date.setTime(date.getTime() + (days * 24 * 60 * 60 * 1000));
document.cookie = `${name}=${value}; expires=${date.toUTCString()}; path=/`;
}
function assignVariation() {
let variation = getCookie(`ab_test_${TEST_ID}`);
if (!variation) {
// Simple random assignment (can be more sophisticated server-side)
const randomIndex = Math.floor(Math.random() * VARIATIONS.length);
variation = VARIATIONS[randomIndex];
setCookie(`ab_test_${TEST_ID}`, variation, 30); // Cookie lasts 30 days
}
return variation;
}
function applyVariation(variation) {
if (variation === 'control') return; // No changes needed
if (variation === 'variation_a') {
// Example: Change hero banner headline
const headlineElement = document.querySelector('.hero-banner h1');
if (headlineElement) {
headlineElement.textContent = 'Shop Smarter, Save Bigger!';
}
} else if (variation === 'variation_b') {
const headlineElement = document.querySelector('.hero-banner h1');
if (headlineElement) {
headlineElement.textContent = 'Exclusive Deals Just For You!';
}
}
// Add more variation logic here...
}
function trackEvent(eventName, data = {}) {
fetch(API_ENDPOINT, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
testId: TEST_ID,
variation: getCookie(`ab_test_${TEST_ID}`),
event: eventName,
data: { ...data, pageUrl: window.location.href }
})
}).catch(error => console.error('AB Test tracking error:', error));
}
const assignedVariation = assignVariation();
applyVariation(assignedVariation);
// Track page view for the assigned variation
trackEvent('page_view');
// Example: Track add to cart clicks
document.querySelectorAll('.add-to-cart-button').forEach(button => {
button.addEventListener('click', () => {
trackEvent('add_to_cart', { productId: button.dataset.productId });
});
});
})();
5. Intelligent Order Routing & Fulfillment Optimization
For businesses with multiple warehouses or drop-shipping partners, efficiently routing orders to the optimal fulfillment location is crucial for reducing shipping costs and delivery times. This SaaS would analyze order details, inventory levels across locations, shipping costs, and delivery estimates to make intelligent routing decisions.
Monetization could be per-order processed, tiered based on order volume, or a subscription model with advanced optimization algorithms. Integration with existing e-commerce platforms and WMS (Warehouse Management Systems) is key.
Order Routing Logic (Python/Django)
A Django application can model warehouses, inventory, shipping methods, and orders. The core logic would involve querying available inventory and calculating the best fulfillment option.
# models.py (simplified Django models)
from django.db import models
class Warehouse(models.Model):
name = models.CharField(max_length=100)
location = models.CharField(max_length=100) # e.g., "New York, NY"
class Product(models.Model):
sku = models.CharField(max_length=50, unique=True)
name = models.CharField(max_length=200)
class Inventory(models.Model):
product = models.ForeignKey(Product, on_delete=models.CASCADE)
warehouse = models.ForeignKey(Warehouse, on_delete=models.CASCADE)
quantity = models.PositiveIntegerField(default=0)
class ShippingRate(models.Model):
origin_warehouse = models.ForeignKey(Warehouse, on_delete=models.CASCADE, related_name='shipping_rates')
destination_zip_code = models.CharField(max_length=10)
carrier = models.CharField(max_length=50)
service = models.CharField(max_length=50)
cost = models.DecimalField(max_digits=10, decimal_places=2)
estimated_delivery_days = models.PositiveIntegerField()
class Order(models.Model):
order_id = models.CharField(max_length=100, unique=True)
# ... other order details ...
fulfilled_from_warehouse = models.ForeignKey(Warehouse, null=True, blank=True, on_delete=models.SET_NULL)
shipping_cost = models.DecimalField(max_digits=10, decimal_places=2, null=True, blank=True)
estimated_delivery_date = models.DateField(null=True, blank=True)
# views.py (simplified order processing logic)
from django.shortcuts import render
from .models import Order, Product, Warehouse, Inventory, ShippingRate
from django.db.models import F
import datetime
def process_order(order_id):
try:
order = Order.objects.get(order_id=order_id)
# Assume order.items is a list of {'product_sku': sku, 'quantity': qty}
order_items = order.items # This needs to be properly modeled
best_option = None # {'warehouse': Warehouse, 'total_cost': float, 'delivery_days': int}
for warehouse in Warehouse.objects.all():
total_cost_for_warehouse = 0.0
total_delivery_days = 0
can_fulfill_all = True
for item in order_items:
product = Product.objects.get(sku=item['product_sku'])
try:
inventory = Inventory.objects.get(product=product, warehouse=warehouse)
if inventory.quantity < item['quantity']:
can_fulfill_all = False
break
except Inventory.DoesNotExist:
can_fulfill_all = False
break
if not can_fulfill_all:
continue
# Calculate shipping cost from this warehouse
# This is a simplified lookup; real-world needs a shipping API integration
shipping_rates = ShippingRate.objects.filter(origin_warehouse=warehouse, destination_zip_code=order.shipping_zip_code)
# Find the cheapest/fastest relevant rate
cheapest_rate = shipping_rates.order_by('cost').first() # Example: cheapest
if cheapest_rate:
total_cost_for_warehouse = cheapest_rate.cost # Simplified, doesn't account for item weight/size
total_delivery_days = cheapest_rate.estimated_delivery_days
# Update inventory (deduct items) - this should be transactional
for item in order_items:
product = Product.objects.get(sku=item['product_sku'])
Inventory.objects.filter(product=product, warehouse=warehouse).update(quantity=F('quantity') - item['quantity'])
if best_option is None or total_cost_for_warehouse < best_option['total_cost']:
best_option = {
'warehouse': warehouse,
'total_cost': total_cost_for_warehouse,
'delivery_days': total_delivery_days
}
if best_option:
order.fulfilled_from_warehouse = best_option['warehouse']
order.shipping_cost = best_option['total_cost']
order.estimated_delivery_date = datetime.date.today() + datetime.timedelta(days=best_option['delivery_days'])
order.save()
print(f"Order {order_id} routed to {best_option['warehouse'].name}")
return True
else:
print(f"Could not find suitable fulfillment option for order {order_id}")
# Trigger backorder process or manual review
return False
except Order.DoesNotExist:
print(f"Order {order_id} not found.")
return False
except Exception as e:
print(f"Error processing order {order_id}: {e}")
return False
# Example usage (within a Django shell or view):
# process_order("ORD789012")
6. Automated Product Data Enrichment & Categorization
E-commerce product catalogs can be messy. A SaaS that automatically enriches product data (e.g., extracting attributes from descriptions, generating SEO-friendly titles/descriptions, finding related products) and categorizes them accurately is highly valuable. This reduces manual effort and improves searchability and conversion rates.
Monetization could be per-product processed, tiered by data complexity, or a subscription for ongoing enrichment. Offer integrations with PIM (Product Information Management) systems.
Data Extraction & Categorization (Python/spaCy)
Natural Language Processing (NLP) libraries like spaCy are excellent for extracting structured information from unstructured text. This can be combined with machine learning models for categorization.
import spacy
from spacy.matcher import Matcher
import requests # For potential external data enrichment
# Load a pre-trained spaCy model
# python -m spacy download en_core_web_sm
nlp = spacy.load("en_core_web_sm")
# Example product description
description = """
Introducing the new UltraWidget Pro X. This advanced gadget features a 10-inch HD display,
128GB of storage, and a powerful A15 Bionic chip. Perfect for professionals and creatives.
Available in Space Gray and Silver. Includes USB-C charging cable. Water-resistant (IP67).
Manufactured by TechCorp. Model: UW-PROX-128.
"""
# --- Attribute Extraction ---
matcher = Matcher(nlp.vocab)
# Pattern for storage size (e.g., "128GB")
storage_pattern = [{"SHAPE": "ddg"}, {"LOWER": "gb"}]
matcher.add("STORAGE_SIZE", [storage_pattern])
# Pattern for screen size (e.g., "10-inch")
screen_pattern = [{"SHAPE": "d.d"}, {"LOWER": "inch"}]
matcher.add("SCREEN_SIZE", [screen_pattern])
# Pattern for model number (e.g., "UW-PROX-128")
model_pattern = [{"IS_UPPER": True, "LENGTH": 4}, {"IS_PUNCT": True}, {"IS_UPPER": True, "LENGTH": 3}, {"IS_PUNCT": True}, {"IS_DIGIT": True}]
matcher.add("MODEL_NUMBER", [model_pattern])
doc = nlp(description)
extracted_attributes = {}
for match_id, start, end in matcher(doc):
span = doc[start:end]
rule_id = nlp.vocab.strings[match_id]
extracted_attributes[rule_id] = span.text
print(f"Found attribute: {rule_id} - {span.text}")
# Extracting Manufacturer (simple noun chunking or NER)
manufacturer = None
for ent in doc.ents:
if ent.label_ == "ORG": # Organizations often include manufacturers
# Basic check to see if it looks like a manufacturer name
if "Corp" in ent.text or "Inc" in ent.text or "Ltd" in ent.text:
manufacturer = ent.text
print(f"Found Manufacturer (NER): {manufacturer}")
break
if not manufacturer: # Fallback if NER didn't catch it clearly
for chunk in doc.noun_chunks:
if "TechCorp" in chunk.text: # Example specific keyword
manufacturer = chunk.text
print(f"Found Manufacturer (Noun Chunk): {manufacturer}")
break
extracted_attributes["MANUFACTURER"] = manufacturer
# --- Categorization (Simplified Example) ---
# In a real SaaS, this would use a trained classification model
def categorize_product(description):
description_lower = description.lower()
if "gadget" in description_lower or "chip" in description_lower or "display" in description_lower:
return "Electronics"
elif "clothing" in description_lower or "apparel" in description_lower:
return "Fashion"
else:
return "General Merchandise"
category = categorize_product(description)
print(f"Predicted Category: {category}")
# --- Further Enrichment (Example: Fetching data from external API) ---
# def enrich_with_external_data(sku):
# try:
# response = requests.get(f"https://api.example.com/product_data/{sku}")
# response.raise_for_status()
# return response.json()
# except requests.exceptions.RequestException as e:
# print(f"External data enrichment failed: {e}")
# return None
# external_data = enrich_with_external_data(extracted_attributes.get("MODEL_NUMBER"))
# if external_data:
# print("External Data:", external_data)
# Final structured data
product_data = {
"description": description,
"attributes": extracted_attributes,
"category": category
}
print("\nFinal Structured Data:")
print(product_data)
7. Automated SEO Audit & Content Gap Analysis Tool
E-commerce SEO is complex. A tool that automates technical SEO audits (crawlability, indexability, mobile-friendliness), identifies keyword gaps compared to competitors, and suggests content improvements (product descriptions, blog posts) can be a game-changer. Focus on actionable insights rather than just data dumps.
Monetization: Tiered plans based on the number of pages crawled, number of competitor comparisons, and depth of analysis. Offer white-labeling for agencies.
Website Crawling & Analysis (Python/Scrapy)
Scrapy is a powerful Python framework for web crawling. It can be used to build a robust crawler that extracts on-page SEO elements and identifies potential issues.
# Example Scrapy Spider (simplified)
import scrapy
from scrapy.linkextractors import LinkExtractor
from scrapy.spiders import CrawlSpider, Rule
from urllib.parse import urlparse
class SeoAuditSpider(CrawlSpider):
name = 'seo_audit'
allowed_domains = ['example-ecommerce.com'] # Replace with target domain
start_urls = ['https://example-ecommerce.com/']
rules = (
# Rule to follow links within the same domain
Rule(LinkExtractor(allow_domains=allowed_domains), callback='parse_item', follow=True),
)
def parse_item(self, response):
url = response.url
parsed_url = urlparse(url)
domain = parsed_url.netloc
# Basic SEO Checks
title = response.css('title::text').get()
meta_description = response.css('meta[name="description"]::attr(content)').get()
h1_tags = response.css('h1::text').getall()
canonical_link = response.css('link[rel="canonical"]::attr(href)').get()
# Check for missing elements
missing_elements = []
if not title: missing_elements.append('Missing Title Tag')
if not meta_description: missing_elements.append('Missing Meta Description')
if not h1_tags: missing_elements.append('Missing H1 Tag')
if not canonical_link and not url.endswith('/'): # Canonical is often optional on root/index pages
missing_elements.append('Missing Canonical Tag')
# Internal linking check (simple count)
internal_links = LinkExtractor(allow_domains=self.allowed_domains).extract_links(response)
num_internal_links = len(internal_links)
# External linking check (simple count)
external_links = LinkExtractor(allow_domains=False, deny_domains=self.allowed_domains).extract_links(response)
num_external_links = len(external_links)
# Image alt text check (simple count)
images_without_alt = response.css('img:not([alt])').getall()
num_images_without_alt = len(images_without_alt)
# Yield data for analysis
yield {
'url': url,
'title': title.strip() if title else None,
'meta_description': meta_description.strip() if meta_description else None,
'h1_tags': [h1.strip() for h1 in h1_tags],
'canonical_link': canonical_link,
'missing_elements': missing_elements,
'num_internal_links': num_internal_links,
'num_external_links': num_external_links,
'num_images_without_alt': num_images_without_alt,
'status_code': response.status,
}
# You would typically run this spider using:
# scrapy crawl seo_audit -o results.json
# The SaaS backend would then process 'results.json' and generate reports.
8. Automated Customer Review Aggregation & Sentiment Analysis
Managing reviews across multiple platforms (Google My Business, Yelp, social media, own website) is time-consuming. A SaaS that aggregates these reviews into a single dashboard and provides sentiment analysis can help businesses quickly understand customer feedback and respond effectively.
Monetization: Per-platform integration, number of reviews processed, or tiered subscription based on features (sentiment analysis, response templates, competitor monitoring).
Review Aggregation & Sentiment (Python/NLTK or TextBlob)
This involves integrating with various platform APIs (where available) or using web scraping techniques. Sentiment analysis can be performed using libraries like NLTK or TextBlob.
from textblob import TextBlob
import requests # For hypothetical API calls to review platforms
# --- Mock Review Data ---
# In reality, you'd fetch this from APIs (Google Places API, Yelp API, etc.)
# or scrape web pages.
reviews_data = [
{"platform": "Google", "text": "Amazing product! Fast shipping and great quality. Highly recommend."},
{"platform": "Yelp", "text": "The service was terrible. Waited 30 minutes for a cold meal."},
{"platform": "OwnSite", "text": "Good value for money, but the instructions were a bit unclear."},
{"platform": "Google", "text": "It's okay, nothing special. Met expectations."},
{"platform": "Twitter", "text": "Absolutely love my new purchase from @YourBrand! #happycustomer"},
]
def analyze_sentiment(text):
analysis = TextBlob(text)
# Polarity is a float within the range [-1.0, 1.0]
# Subjectivity is a float within the range [0.0, 1.0] where 0.0 is very objective and 1.0 is very subjective.
polarity = analysis.sentiment.polarity
subjectivity = analysis.sentiment.subjectivity
if polarity >= 0.5:
sentiment = "Positive"
elif polarity <= -0.5:
sentiment = "Negative"
else:
sentiment