diff --git a/examples/startups/blocksense.mdx b/examples/startups/blocksense.mdx
new file mode 100644
index 000000000..846f2cdaa
--- /dev/null
+++ b/examples/startups/blocksense.mdx
@@ -0,0 +1,509 @@
+---
+title: "BlockSense - Predictive Maintenance for Block/Brick Manufacturing"
+description: "AI-powered predictive maintenance platform reducing unplanned downtime 15-25% in concrete block and brick plants"
+industry: "Manufacturing Technology"
+stage: "Product Development"
+founded: "2024"
+geography: "North America"
+tags: ["predictive-maintenance", "manufacturing", "ai", "iot", "concrete-block", "brick-manufacturing"]
+---
+
+# BlockSense Business Workflows
+
+BlockSense is a predictive maintenance platform specifically designed for concrete block and brick manufacturing plants. We reduce unplanned downtime by 15-25% within 6 months by turning existing PLC logs and maintenance history into accurate failure predictions and actionable work orders.
+
+## Core Business Process Functions
+
+```typescript exec
+// Customer Acquisition Workflow
+export async function acquireCustomer(lead: Lead): Promise<Customer> {
+  // Qualify lead based on plant size and equipment
+  const qualifiedLead = await qualifyLead(lead)
+  
+  // Generate custom proposal with ROI calculations
+  const proposal = await generateProposal(qualifiedLead)
+  
+  // Conduct technical assessment and pilot planning
+  const technicalAssessment = await conductTechnicalAssessment(qualifiedLead)
+  
+  // Negotiate contract terms
+  const contract = await negotiateContract(proposal, technicalAssessment)
+  
+  // Onboard customer with 90-day pilot
+  return await onboardCustomer(contract)
+}
+
+// Lead Qualification Process
+export async function qualifyLead(lead: Lead): Promise<QualifiedLead> {
+  const plantProfile = await assessPlantProfile(lead)
+  
+  // Check if plant meets minimum criteria
+  if (plantProfile.assetCount < 8 || plantProfile.productionLines < 1) {
+    throw new Error('Plant does not meet minimum asset requirements')
+  }
+  
+  const economicProfile = await calculateEconomicProfile(plantProfile)
+  const technicalReadiness = await assessTechnicalReadiness(plantProfile)
+  
+  return {
+    ...lead,
+    plantProfile,
+    economicProfile,
+    technicalReadiness,
+    qualificationScore: calculateQualificationScore(economicProfile, technicalReadiness)
+  }
+}
+
+// Proposal Generation
+export async function generateProposal(qualifiedLead: QualifiedLead): Promise<Proposal> {
+  const roiCalculation = await calculateROI(qualifiedLead)
+  const implementationPlan = await createImplementationPlan(qualifiedLead)
+  const pricing = await calculatePricing(qualifiedLead)
+  
+  return {
+    customerId: qualifiedLead.id,
+    roiCalculation,
+    implementationPlan,
+    pricing,
+    pilotTerms: await generatePilotTerms(qualifiedLead),
+    successCriteria: await defineSuccessCriteria(qualifiedLead)
+  }
+}
+
+// Product Development Workflow
+export async function developPredictiveModel(assetType: AssetType, failureMode: FailureMode): Promise<PredictiveModel> {
+  // Collect training data from existing installations
+  const trainingData = await collectTrainingData(assetType, failureMode)
+  
+  // Feature engineering for PLC signals
+  const features = await engineerFeatures(trainingData)
+  
+  // Train domain-specific model
+  const model = await trainModel(features, failureMode)
+  
+  // Validate model performance
+  const validation = await validateModel(model, trainingData)
+  
+  if (validation.recall < 0.7 || validation.precision < 0.8) {
+    throw new Error('Model performance below acceptable thresholds')
+  }
+  
+  // Deploy to model library
+  return await deployToModelLibrary(model, validation)
+}
+
+// Revenue Generation Flow
+export async function generateRevenue(customer: Customer, month: number): Promise<Revenue> {
+  // Calculate SaaS subscription revenue
+  const subscriptionRevenue = await calculateSubscriptionRevenue(customer, month)
+  
+  // Check for expansion opportunities
+  const expansionOpportunities = await identifyExpansionOpportunities(customer)
+  
+  // Process any outcome-based bonuses
+  const outcomeBonus = await calculateOutcomeBonus(customer, month)
+  
+  // Handle renewals and upsells
+  const renewalRevenue = await processRenewals(customer, month)
+  
+  return {
+    customerId: customer.id,
+    month,
+    subscriptionRevenue,
+    expansionRevenue: expansionOpportunities.revenue,
+    outcomeBonus,
+    renewalRevenue,
+    totalRevenue: subscriptionRevenue + expansionOpportunities.revenue + outcomeBonus + renewalRevenue
+  }
+}
+
+// Operational Procedures
+export async function deploySystem(customer: Customer): Promise<Deployment> {
+  // Install edge gateway hardware
+  const gatewayInstallation = await installEdgeGateway(customer)
+  
+  // Configure PLC/SCADA connections
+  const plcConnections = await configurePLCConnections(customer, gatewayInstallation)
+  
+  // Set up CMMS integration
+  const cmmsIntegration = await setupCMMSIntegration(customer)
+  
+  // Deploy predictive models
+  const modelDeployment = await deployPredictiveModels(customer)
+  
+  // Configure dashboards and alerts
+  const dashboardSetup = await setupDashboards(customer)
+  
+  // Conduct user training
+  const training = await conductUserTraining(customer)
+  
+  return {
+    customerId: customer.id,
+    gatewayInstallation,
+    plcConnections,
+    cmmsIntegration,
+    modelDeployment,
+    dashboardSetup,
+    training,
+    status: 'deployed',
+    deploymentDate: new Date()
+  }
+}
+
+// Decision-Making Workflows
+export async function evaluateExpansionOpportunity(customer: Customer): Promise<ExpansionDecision> {
+  // Analyze current performance metrics
+  const performanceMetrics = await analyzePerformanceMetrics(customer)
+  
+  // Assess customer satisfaction and adoption
+  const customerHealth = await assessCustomerHealth(customer)
+  
+  // Calculate expansion ROI
+  const expansionROI = await calculateExpansionROI(customer, performanceMetrics)
+  
+  // Check technical feasibility
+  const technicalFeasibility = await assessExpansionFeasibility(customer)
+  
+  const decision = {
+    customerId: customer.id,
+    recommendExpansion: expansionROI.roi > 3.0 && customerHealth.score > 0.8,
+    expansionType: determineExpansionType(customer, technicalFeasibility),
+    expectedRevenue: expansionROI.expectedRevenue,
+    timeline: calculateExpansionTimeline(customer, technicalFeasibility),
+    riskFactors: identifyRiskFactors(customer, performanceMetrics)
+  }
+  
+  return decision
+}
+
+// Customer Success Workflow
+export async function ensureCustomerSuccess(customer: Customer): Promise<SuccessMetrics> {
+  // Monitor key performance indicators
+  const kpis = await monitorKPIs(customer)
+  
+  // Track alert performance
+  const alertPerformance = await trackAlertPerformance(customer)
+  
+  // Measure downtime reduction
+  const downtimeReduction = await measureDowntimeReduction(customer)
+  
+  // Calculate ROI achievement
+  const roiAchievement = await calculateROIAchievement(customer, downtimeReduction)
+  
+  // Identify improvement opportunities
+  const improvements = await identifyImprovements(customer, kpis)
+  
+  // Schedule regular check-ins
+  await scheduleCustomerCheckIn(customer, improvements)
+  
+  return {
+    customerId: customer.id,
+    kpis,
+    alertPerformance,
+    downtimeReduction,
+    roiAchievement,
+    improvements,
+    successScore: calculateSuccessScore(kpis, alertPerformance, downtimeReduction)
+  }
+}
+
+// Partnership Development
+export async function developOEMPartnership(oem: OEMPartner): Promise<Partnership> {
+  // Assess partnership fit
+  const partnershipFit = await assessPartnershipFit(oem)
+  
+  // Negotiate partnership terms
+  const terms = await negotiatePartnershipTerms(oem, partnershipFit)
+  
+  // Develop co-selling materials
+  const coSellingMaterials = await developCoSellingMaterials(oem)
+  
+  // Train partner sales team
+  const partnerTraining = await trainPartnerSalesTeam(oem, coSellingMaterials)
+  
+  // Set up revenue sharing
+  const revenueSharing = await setupRevenueSharing(oem, terms)
+  
+  return {
+    partnerId: oem.id,
+    partnershipType: 'OEM',
+    terms,
+    coSellingMaterials,
+    partnerTraining,
+    revenueSharing,
+    status: 'active',
+    startDate: new Date()
+  }
+}
+
+// Market Expansion Workflow
+export async function expandToNewMarket(market: Market): Promise<MarketExpansion> {
+  // Research market opportunity
+  const marketResearch = await conductMarketResearch(market)
+  
+  // Assess regulatory requirements
+  const regulatoryAssessment = await assessRegulatoryRequirements(market)
+  
+  // Adapt product for local requirements
+  const productAdaptation = await adaptProductForMarket(market, regulatoryAssessment)
+  
+  // Establish local partnerships
+  const localPartnerships = await establishLocalPartnerships(market)
+  
+  // Launch go-to-market strategy
+  const gtmLaunch = await launchGTMStrategy(market, localPartnerships)
+  
+  return {
+    marketId: market.id,
+    marketResearch,
+    regulatoryAssessment,
+    productAdaptation,
+    localPartnerships,
+    gtmLaunch,
+    status: 'launched',
+    launchDate: new Date()
+  }
+}
+```
+
+## Type Definitions
+
+```typescript exec
+// Core business types
+interface Lead {
+  id: string
+  companyName: string
+  contactPerson: string
+  email: string
+  phone: string
+  plantLocation: string
+  productionType: 'concrete-block' | 'brick' | 'both'
+  annualProduction: number
+  currentDowntimeHours: number
+  source: 'direct' | 'partner' | 'referral' | 'marketing'
+}
+
+interface QualifiedLead extends Lead {
+  plantProfile: PlantProfile
+  economicProfile: EconomicProfile
+  technicalReadiness: TechnicalReadiness
+  qualificationScore: number
+}
+
+interface PlantProfile {
+  assetCount: number
+  productionLines: number
+  equipmentTypes: AssetType[]
+  plcSystems: string[]
+  cmmsSystem: string
+  maintenanceApproach: 'reactive' | 'preventive' | 'predictive'
+}
+
+interface EconomicProfile {
+  downtimeCostPerHour: number
+  annualMaintenanceBudget: number
+  potentialSavings: number
+  paybackPeriod: number
+}
+
+interface TechnicalReadiness {
+  networkConnectivity: boolean
+  dataAccessibility: boolean
+  itSecurityCompliance: boolean
+  maintenanceTeamCapability: number
+}
+
+interface Customer {
+  id: string
+  companyName: string
+  contractValue: number
+  assetsMonitored: number
+  deploymentDate: Date
+  contractEndDate: Date
+  status: 'pilot' | 'active' | 'expansion' | 'churned'
+}
+
+interface AssetType {
+  type: 'press' | 'mixer' | 'conveyor' | 'hydraulic-pump' | 'gearbox' | 'bearing'
+  manufacturer: string
+  model: string
+  criticalityLevel: 'high' | 'medium' | 'low'
+}
+
+interface FailureMode {
+  name: string
+  assetType: AssetType
+  symptoms: string[]
+  leadTimeHours: number
+  impactLevel: 'critical' | 'major' | 'minor'
+}
+
+interface PredictiveModel {
+  id: string
+  assetType: AssetType
+  failureMode: FailureMode
+  accuracy: number
+  precision: number
+  recall: number
+  deploymentDate: Date
+}
+
+interface Revenue {
+  customerId: string
+  month: number
+  subscriptionRevenue: number
+  expansionRevenue: number
+  outcomeBonus: number
+  renewalRevenue: number
+  totalRevenue: number
+}
+
+interface Deployment {
+  customerId: string
+  gatewayInstallation: any
+  plcConnections: any
+  cmmsIntegration: any
+  modelDeployment: any
+  dashboardSetup: any
+  training: any
+  status: string
+  deploymentDate: Date
+}
+
+interface ExpansionDecision {
+  customerId: string
+  recommendExpansion: boolean
+  expansionType: string
+  expectedRevenue: number
+  timeline: number
+  riskFactors: string[]
+}
+
+interface SuccessMetrics {
+  customerId: string
+  kpis: any
+  alertPerformance: any
+  downtimeReduction: number
+  roiAchievement: number
+  improvements: string[]
+  successScore: number
+}
+
+interface OEMPartner {
+  id: string
+  name: string
+  equipmentTypes: AssetType[]
+  marketPresence: string[]
+  partnershipInterest: number
+}
+
+interface Partnership {
+  partnerId: string
+  partnershipType: string
+  terms: any
+  coSellingMaterials: any
+  partnerTraining: any
+  revenueSharing: any
+  status: string
+  startDate: Date
+}
+
+interface Market {
+  id: string
+  region: string
+  countries: string[]
+  marketSize: number
+  competitionLevel: number
+  regulatoryComplexity: number
+}
+
+interface MarketExpansion {
+  marketId: string
+  marketResearch: any
+  regulatoryAssessment: any
+  productAdaptation: any
+  localPartnerships: any
+  gtmLaunch: any
+  status: string
+  launchDate: Date
+}
+```
+
+## Business Process Orchestration
+
+```typescript exec
+// Main business orchestration workflow
+export async function runBlockSenseBusiness(): Promise<void> {
+  // Initialize business operations
+  const businessState = await initializeBusinessState()
+  
+  // Set up event listeners for key business processes
+  on('lead.captured', async (lead: Lead) => {
+    try {
+      const customer = await acquireCustomer(lead)
+      await deploySystem(customer)
+      emit('customer.onboarded', customer)
+    } catch (error) {
+      emit('lead.qualification.failed', { lead, error })
+    }
+  })
+  
+  on('customer.onboarded', async (customer: Customer) => {
+    // Start monitoring customer success
+    setInterval(async () => {
+      const successMetrics = await ensureCustomerSuccess(customer)
+      if (successMetrics.successScore > 0.8) {
+        const expansionDecision = await evaluateExpansionOpportunity(customer)
+        if (expansionDecision.recommendExpansion) {
+          emit('expansion.opportunity', { customer, decision: expansionDecision })
+        }
+      }
+    }, 30 * 24 * 60 * 60 * 1000) // Monthly check
+  })
+  
+  on('expansion.opportunity', async ({ customer, decision }) => {
+    const expandedRevenue = await generateRevenue(customer, new Date().getMonth())
+    emit('revenue.generated', expandedRevenue)
+  })
+  
+  // Continuous product development
+  setInterval(async () => {
+    const newFailureModes = await identifyNewFailureModes()
+    for (const failureMode of newFailureModes) {
+      const model = await developPredictiveModel(failureMode.assetType, failureMode)
+      emit('model.deployed', model)
+    }
+  }, 90 * 24 * 60 * 60 * 1000) // Quarterly model updates
+  
+  // Partnership development
+  setInterval(async () => {
+    const potentialPartners = await identifyPotentialOEMPartners()
+    for (const partner of potentialPartners) {
+      const partnership = await developOEMPartnership(partner)
+      emit('partnership.established', partnership)
+    }
+  }, 180 * 24 * 60 * 60 * 1000) // Semi-annual partnership review
+}
+
+// Helper functions (pseudocode implementations)
+async function initializeBusinessState() {
+  return {
+    customers: [],
+    models: [],
+    partnerships: [],
+    revenue: 0
+  }
+}
+
+async function identifyNewFailureModes(): Promise<FailureMode[]> {
+  // Analyze customer data to identify new failure patterns
+  return []
+}
+
+async function identifyPotentialOEMPartners(): Promise<OEMPartner[]> {
+  // Research and identify potential OEM partners
+  return []
+}
+```
+
+This MDX file defines the core business processes for BlockSense as executable TypeScript functions, representing the complete workflow from customer acquisition through revenue generation and business expansion.