Technology Stack for AI-Powered Coworking Space

Overview

This document outlines the complete technology stack for building and operating your AI-powered coworking space, from smart locks to member portal to AI systems.

Philosophy: Start simple, automate incrementally, build vs. buy where your skills allow.

1. Smart Access Control

Smart Lock System

Recommended: Latch (Commercial Grade)

Why: Built for commercial/multifamily, robust API, good support

Cost: ~$400-600 per door + $10-20/month per lock

Features: Bluetooth unlock, app access, access codes, audit trail, API for integration

API: RESTful, webhooks for events

Alternatives:

What You Need:

2-3 locks (main entrance, possibly individual unit doors)

Latch Manager account

WiFi bridge/hub for connectivity

Integration Plan:

Your Rails app

class AccessControlService
  def grant_access(member, start_time, end_time)
    # Call Latch API to create access code
    # Or grant Bluetooth access via mobile app
  end
  def revoke_access(member)
    # Remove access when membership expires
  end  def log_entry(event)
    # Webhook from Latch when door unlocked
    # Track who entered when
  end
end

Access Control Flow

1. Member signs up → Stripe subscription created
2. Your system creates Latch user + grants access
3. Member gets email with app download link
4. Member uses phone to unlock door (Bluetooth or app-based unlock)
5. Entry logged in your dashboard
6. Member cancels → Access automatically revoked

2. Member Portal & Management

Backend: Ruby on Rails

Why Rails?

You know it well (TaskYou experience)

Rapid development

Great for business logic

Strong ecosystem

Core Models:

app/models/

User (Devise for auth)

Membership (subscription tiers, status)

Booking (desk/room reservations)

AccessLog (entry/exit tracking)

Event (community events)

Invoice (Stripe integration)

Feedback (member surveys, NPS)

Key Features:

User authentication (Devise + OmniAuth for OAuth)

Subscription management (Stripe integration)

Booking system (desks, rooms, resources)

Access control integration

Analytics dashboard (for you)

Member directory

Event management

Feedback collection

Frontend: Hotwire (Turbo + Stimulus)

Why Hotwire?

Minimal JavaScript

Real-time updates (Turbo Streams)

Fast development

Aligns with your Rails expertise

Key Views:

Dashboard (member's home - upcoming bookings, announcements)

Booking interface (calendar view for rooms, desk availability)

Profile management

Community directory

Event listings

Real-time Features:

Turbo Streams for live updates

When someone books a room, all users see availability update

class BookingsController < ApplicationController
  def create
    @booking = current_user.bookings.create(booking_params)    respond_to do |format|
      format.turbo_stream # Updates availability in real-time
      format.html
    end
  end
end

Mobile: Progressive Web App (PWA)

Why PWA vs Native?

Single codebase (your Rails app)

No app store approval

Still installable on home screen

Push notifications (for door access, bookings)

Works on iOS and Android

Key Mobile Features:

Door unlock (integrate with Latch SDK or deep link to Latch app)

Quick booking

Event check-in

Notifications

Tech:

Service Worker for offline support

Web Push API for notifications

Hotwire Native if you want native app feel later

3. AI & Automation

AI Chatbot: Member Support

LLM Provider: Claude (via Anthropic API)

Why: Best for nuanced, helpful responses; you're familiar from your work

Cost: ~$0.01-0.05 per conversation (very affordable)

Use cases:

Implementation:

app/services/ai_concierge_service.rb

class AiConciergeService
  def initialize(member)
    @member = member
    @client = Anthropic::Client.new(api_key: ENV['ANTHROPIC_API_KEY'])
  end
  def chat(message)
    context = build_context # member info, current bookings, space availability
    response = @client.messages(
      model: "claude-3-5-sonnet-20241022",
      messages: [
        { role: "user", content: message }
      ],
      system: ai_system_prompt(context),
      tools: available_tools # booking, issue reporting, etc.
    )
    handle_tool_calls(response) if response.tool_calls?
    response.content
  end
  private  def available_tools
    [
      {
        name: "book_room",
        description: "Book a meeting room for the member",
        input_schema: {
          type: "object",
          properties: {
            room_id: { type: "string" },
            start_time: { type: "string" },
            duration_hours: { type: "number" }
          }
        }
      },
      {
        name: "report_issue",
        description: "Create a maintenance or issue ticket",
        input_schema: {
          type: "object",
          properties: {
            description: { type: "string" },
            priority: { type: "string", enum: ["low", "medium", "high"] }
          }
        }
      }
      # ... more tools
    ]
  end
end

Where Chatbot Appears:

Member portal (chat widget)

Text message (Twilio integration)

Eventually: Voice (phone call to space)

AI Features to Build (Priority Order)

Phase 1 (Launch):
1. ✅ Basic Q&A chatbot (hours, amenities, how-tos)
2. ✅ Booking assistant ("Book me a 4-person room for 2pm tomorrow")
3. ✅ Issue reporting automation

Phase 2 (Month 3-6):
4. Member matching ("Find me someone who knows Python")
5. Personalized environment (learns your preferences)
6. Smart scheduling (suggests best times based on occupancy)

Phase 3 (Month 7-12):
7. Productivity insights ("You're most productive 9-11am on Tuesdays")
8. Community event generation (AI organizes member lunches)
9. Predictive maintenance (AI detects equipment issues before they happen)

Machine Learning: Occupancy Prediction

Goal: Predict when space will be busy to optimize HVAC, suggest booking times

Approach:
1. Collect data (who's here when, desk/room usage, external factors like weather)
2. Simple model to start (linear regression or decision tree)
3. Feed predictions to members and building systems

Tools:

Python + scikit-learn (for model)

Rails calls Python service (microservice or Flask API)

Or use hosted ML (AWS SageMaker, Google AutoML)

Implementation:

occupancy_predictor.py (separate microservice)

import pandas as pd
from sklearn.ensemble import RandomForestRegressorclass OccupancyPredictor:
    def predict(self, day_of_week, hour, weather, holidays):
        # Load historical data
        # Train model
        # Return predicted occupancy (0-100%)
        pass

app/services/occupancy_service.rb

class OccupancyService
  def predict_tomorrow
    response = HTTParty.post('http://localhost:5000/predict',
      body: {
        day_of_week: Date.tomorrow.wday,
        weather: fetch_weather_forecast,
        holidays: is_holiday?(Date.tomorrow)
      }.to_json
    )
    response['occupancy_percentage']
  end  def send_member_alerts
    if predict_tomorrow > 80
      Member.active.each do |member|
        MemberMailer.high_occupancy_alert(member).deliver_later
      end
    end
  end
end

4. Smart Building & IoT

IoT Hub: Home Assistant

Why Home Assistant?

Open source, local control (privacy)

Supports hundreds of devices

Powerful automation engine

Can integrate with your Rails app via API

Installation:

Raspberry Pi 4 (8GB) running Home Assistant OS (~$100)

Or dedicated mini PC for reliability

Devices to Integrate:

#### Occupancy Sensors

Aqara Motion Sensors (~$20 each, Zigbee)

Place in each room, track real-time occupancy

Trigger lights, HVAC based on presence

#### Smart Lighting

Philips Hue or LIFX bulbs (~$15-30 each)

Or smart switches (Lutron, GE) if you have traditional fixtures

Automate: Lights on when occupied, off when empty

Dim based on time of day, natural light levels

#### Climate Control

Ecobee Smart Thermostat (~$200) or Nest (~$250)

Remote sensors for each room

Occupancy-based HVAC (don't heat/cool empty rooms)

Schedule based on predicted usage

#### Environmental Monitoring

Awair Element (~$200) - air quality, CO2, VOCs, temperature, humidity

Or cheaper: Aqara sensors for temp/humidity (~$15)

Alert if air quality poor (open windows, turn on ventilation)

#### Security Cameras

Wyze Cam v3 (~$30 each, affordable, good quality)

Or UniFi Protect (if you go with UniFi network, more expensive but professional)

Exterior cameras (security, package monitoring)

Interior common areas (optional, privacy-sensitive)

Home Assistant Automations

Example Automations:

automation.yaml
Turn on lights when someone arrives

alias: "Workspace Occupied - Lights On"

  trigger:
    - platform: state
      entity_id: binary_sensor.main_room_occupancy
      to: 'on'
  condition:
    - condition: sun
      after: sunset
  action:
    - service: light.turn_on
      entity_id: light.main_workspace
Energy saving: HVAC off when empty for 30min

alias: "Empty Space - Reduce HVAC"

  trigger:
    - platform: state
      entity_id: binary_sensor.space_occupancy
      to: 'off'
      for: '00:30:00'
  action:
    - service: climate.set_temperature
      data:
        entity_id: climate.main_thermostat
        temperature: 65 # Lower in winter, higher in summer
Alert when air quality poor

alias: "Poor Air Quality Alert"

  trigger:
    - platform: numeric_state
      entity_id: sensor.main_room_co2
      above: 1000
  action:
    - service: notify.admin_phone
      data:
        message: "CO2 high in main room. Open windows or check ventilation."

Integration with Rails App

Home Assistant REST API:

app/services/smart_building_service.rb

class SmartBuildingService
  BASE_URL = 'http://homeassistant.local:8123/api'
  def current_occupancy
    response = HTTParty.get("#{BASE_URL}/states/sensor.total_occupancy",
      headers: { 'Authorization' => "Bearer #{ENV['HA_TOKEN']}" }
    )
    response['state'].to_i
  end
  def adjust_climate_for_member(member)
    # Set temperature to member's preference
    temp = member.preferred_temperature || 72
    HTTParty.post("#{BASE_URL}/services/climate/set_temperature",
      headers: { 'Authorization' => "Bearer #{ENV['HA_TOKEN']}" },
      body: {
        entity_id: "climate.main_thermostat",
        temperature: temp
      }.to_json
    )
  end  def trigger_scene(scene_name)
    # Activate scene (e.g., "focus mode", "social mode")
    HTTParty.post("#{BASE_URL}/services/scene/turn_on",
      headers: { 'Authorization' => "Bearer #{ENV['HA_TOKEN']}" },
      body: { entity_id: "scene.#{scene_name}" }.to_json
    )
  end
end

Webhooks from Home Assistant to Rails:

Home Assistant automation that notifies Rails

alias: "Member Arrived - Notify Rails"

  trigger:
    - platform: event
      event_type: latch_unlock
      event_data:
        user_id: "{{ trigger.event.data.user_id }}"
  action:
    - service: rest_command.notify_rails_member_arrival
      data:
        member_id: "{{ trigger.event.data.user_id }}"

config/routes.rb

post '/webhooks/member_arrival', to: 'webhooks#member_arrival'
app/controllers/webhooks_controller.rb

class WebhooksController < ApplicationController
  skip_before_action :verify_authenticity_token
  def member_arrival
    member = Member.find(params[:member_id])
    # Log arrival
    member.access_logs.create(action: 'arrival', timestamp: Time.current)
    # Adjust environment to their preferences
    SmartBuildingService.new.adjust_climate_for_member(member)
    # Send welcome notification to their phone
    MemberNotificationService.new(member).send_arrival_greeting    head :ok
  end
end

5. Payment & Billing

Stripe

Why Stripe?

Industry standard

Excellent API

Handles subscriptions, invoicing, payment methods

Automatic failed payment handling

Stripe Billing for recurring memberships

Setup:

Gemfile

gem 'stripe'
config/initializers/stripe.rb

Stripe.api_key = ENV['STRIPE_SECRET_KEY']
app/models/membership.rb

class Membership < ApplicationRecord
  belongs_to :user
  after_create :create_stripe_subscription
  before_destroy :cancel_stripe_subscription
  def create_stripe_subscription
    customer = Stripe::Customer.create(
      email: user.email,
      payment_method: user.stripe_payment_method_id,
      invoice_settings: { default_payment_method: user.stripe_payment_method_id }
    )
    subscription = Stripe::Subscription.create(
      customer: customer.id,
      items: [{ price: stripe_price_id }],
      expand: ['latest_invoice.payment_intent']
    )
    update(
      stripe_customer_id: customer.id,
      stripe_subscription_id: subscription.id,
      status: 'active'
    )
  end
  def cancel_stripe_subscription
    Stripe::Subscription.delete(stripe_subscription_id) if stripe_subscription_id
  end
  private  def stripe_price_id
    # Map membership tier to Stripe Price ID
    {
      'community' => ENV['STRIPE_PRICE_COMMUNITY'],
      'flex' => ENV['STRIPE_PRICE_FLEX'],
      'dedicated' => ENV['STRIPE_PRICE_DEDICATED']
    }[tier]
  end
end

Stripe Products to Create:

Community Pass: $99/month (recurring)

Flex Membership: $199/month (recurring)

Dedicated Desk: $399/month (recurring)

Private Office: $799/month (recurring)

Day Pass: $25 (one-time)

Meeting Room: $50/hour (one-time)

Webhooks:

config/routes.rb

post '/webhooks/stripe', to: 'stripe_webhooks#create'
app/controllers/stripe_webhooks_controller.rb

class StripeWebhooksController < ApplicationController
  skip_before_action :verify_authenticity_token
  def create
    payload = request.body.read
    sig_header = request.env['HTTP_STRIPE_SIGNATURE']
    event = Stripe::Webhook.construct_event(payload, sig_header, ENV['STRIPE_WEBHOOK_SECRET'])
    case event.type
    when 'invoice.payment_succeeded'
      # Mark membership as active/renewed
    when 'invoice.payment_failed'
      # Suspend access, notify member
    when 'customer.subscription.deleted'
      # Cancel membership, revoke access
    end    head :ok
  end
end

6. Communication & Notifications

Transactional Email: Postmark or SendGrid

Postmark (~$15/month for 10K emails)

Reliable delivery

Good templates

Simple API

Use Cases:

Welcome emails

Booking confirmations

Invoice receipts

Password resets

Weekly digest

Gemfile

gem 'postmark-rails'
config/environments/production.rb

config.action_mailer.delivery_method = :postmark
config.action_mailer.postmark_settings = { api_token: ENV['POSTMARK_API_KEY'] }
app/mailers/member_mailer.rb

class MemberMailer < ApplicationMailer
  def welcome_email(member)
    @member = member
    mail(
      to: member.email,
      subject: "Welcome to [Space Name]!",
      template_name: 'welcome'
    )
  end  def booking_confirmation(booking)
    @booking = booking
    mail(
      to: booking.member.email,
      subject: "Your room is booked for #{booking.start_time.strftime('%b %d at %I:%M%p')}"
    )
  end
end

SMS Notifications: Twilio

Use Cases:

Urgent issues ("Coffee machine broken")

Access codes (if using keypad entry)

Booking reminders

Emergency alerts

Cost: ~$0.01/SMS

Gemfile

gem 'twilio-ruby'
app/services/sms_service.rb

class SmsService
  def initialize
    @client = Twilio::REST::Client.new(ENV['TWILIO_ACCOUNT_SID'], ENV['TWILIO_AUTH_TOKEN'])
  end
  def send_message(to:, body:)
    @client.messages.create(
      from: ENV['TWILIO_PHONE_NUMBER'],
      to: to,
      body: body
    )
  end
end
Usage

SmsService.new.send_message(
  to: member.phone,
  body: "Your meeting room is ready! Room B, 2nd floor."
)

Community: Slack or Discord

Why?

Members want async communication

Share resources, ask questions, coordinate

Builds community cohesion

Recommendation: Slack (Free tier)

Create workspace: [YourSpace].slack.com

Channels: #general, #introductions, #events, #help, #random

Integrate with your Rails app (auto-invite new members)

app/services/slack_service.rb

class SlackService
  def invite_member(member)
    HTTParty.post('https://slack.com/api/admin.users.invite',
      headers: { 'Authorization' => "Bearer #{ENV['SLACK_ADMIN_TOKEN']}" },
      body: {
        team_id: ENV['SLACK_TEAM_ID'],
        email: member.email,
        channel_ids: ENV['SLACK_DEFAULT_CHANNELS']
      }
    )
  end  def post_announcement(message)
    HTTParty.post('https://slack.com/api/chat.postMessage',
      headers: { 'Authorization' => "Bearer #{ENV['SLACK_BOT_TOKEN']}" },
      body: {
        channel: '#general',
        text: message
      }.to_json
    )
  end
end

7. Analytics & Monitoring

Application Monitoring: Honeybadger (or Sentry)

Why?

Catch errors before members report them

Uptime monitoring

Performance insights

Cost: Free tier available, then ~$39/month

Setup:

Gemfile

gem 'honeybadger'
config/honeybadger.yml

api_key: <%= ENV['HONEYBADGER_API_KEY'] %>

Business Analytics: Your Custom Dashboard

What to Track:

Daily active members

Revenue (MRR, churn rate)

Occupancy rates (by hour, day, room)

Booking patterns

Member engagement

Energy usage & costs

Tools:

Chartkick for charts in Rails

Or export data to Google Sheets/Data Studio

app/controllers/admin/analytics_controller.rb

class Admin::AnalyticsController < ApplicationController
  def index
    @metrics = {
      total_members: Member.active.count,
      mrr: calculate_mrr,
      occupancy_today: calculate_occupancy(Date.today),
      churn_rate: calculate_churn_rate
    }
    @occupancy_trend = last_30_days.map { |date|
      { date: date, occupancy: calculate_occupancy(date) }
    }
  end
  private
  def calculate_mrr
    Member.active.joins(:membership).sum(:monthly_price)
  end
  def calculate_occupancy(date)
    # Avg number of members present / total capacity
    access_logs = AccessLog.where(date: date)
    # ... logic to calculate
  end  def calculate_churn_rate
    # (Members who left this month / Total members at start of month) * 100
  end
end

Usage Tracking: Simple Event Logging

app/models/event_log.rb

class EventLog < ApplicationRecord
  # Tracks all significant events
  # - member_arrival
  # - booking_created
  # - room_used
  # - issue_reported
  # - ai_interaction
  scope :member_arrivals, -> { where(event_type: 'member_arrival') }
  scope :today, -> { where('created_at >= ?', Time.current.beginning_of_day) }
end
Log events throughout the app

EventLog.create(
  event_type: 'room_booked',
  member: current_member,
  metadata: { room_id: @room.id, duration: params[:duration] }
)

8. Network Infrastructure

Business Internet

Verizon Fios Business or Comcast Business

500 Mbps minimum (1 Gbps ideal)

Symmetrical upload (important for video calls)

Static IP (for remote access to systems)

SLA (service level agreement for uptime)

Cost: ~$200-400/month depending on speed

Backup Internet (Failover):

Cheap residential line or mobile hotspot

Automatic failover via dual-WAN router

Ensures uptime even if primary fails

WiFi: Ubiquiti UniFi

Why UniFi?

Enterprise-grade, affordable

Central management (UniFi Controller)

Seamless roaming between access points

Guest network isolation

Usage stats per device/user

Rock solid reliability

What to Buy:

UniFi Dream Machine Pro (~$400) - router, controller, security gateway

UniFi 6 Access Points (~$180 each) - 2-3 depending on space size

UniFi Switch (~$200-300) - 24-48 port PoE switch to power APs

Network Design:

Internet → UDM Pro → PoE Switch → Access Points
                  ↓
         Home Assistant, Servers, Cameras

VLANs:

Member network (isolated, limited bandwidth per device)

Guest network (captive portal with password)

IoT network (sensors, cameras, smart devices - firewalled from internet)

Management network (your admin devices)

Controller Dashboard:

See who's connected

Bandwidth usage per member

Block devices if needed

Monitor uptime

9. Software Development Workflow

Version Control: GitHub

Repos:

coworking-platform (your Rails app)

coworking-ml (Python ML models, if separate)

coworking-docs (documentation, runbooks)

Hosting: Render or Heroku

Render (recommended, modern, affordable)

Web service: Rails app (~$25/month for starter)

PostgreSQL: Managed database (~$7/month)

Background workers: Sidekiq for jobs (~$7/month)

Total: ~$40-50/month

Heroku (alternative, more expensive but simpler)

Hobby tier: ~$7/month for web + DB

Scale up as needed

Deployment:

Push to main branch → Auto-deploy to Render

git push origin main
Render builds and deploys automatically

Background Jobs: Sidekiq

For:

Sending emails

Syncing with external APIs (Stripe, Latch)

Generating reports

ML predictions

Gemfile

gem 'sidekiq'
app/jobs/sync_access_logs_job.rb

class SyncAccessLogsJob < ApplicationJob
  queue_as :default
  def perform
    # Fetch access logs from Latch API
    # Update database
  end
end
Schedule with cron (via Sidekiq-cron)

Every 5 minutes: Sync access logs

Every hour: Check for expiring memberships

Every day: Generate analytics report

Testing: RSpec

Gemfile (test group)

gem 'rspec-rails'
gem 'factory_bot_rails'
gem 'faker'
Example test

spec/services/booking_service_spec.rb

RSpec.describe BookingService do
  describe '#create_booking' do
    it 'creates a booking for available room' do
      room = create(:room)
      member = create(:member)
      booking = BookingService.new(member).create_booking(
        room: room,
        start_time: 1.hour.from_now,
        duration: 2
      )
      expect(booking).to be_persisted
      expect(booking.room).to eq(room)
    end    it 'raises error if room unavailable' do
      # ... test conflict detection
    end
  end
end

10. Development Roadmap

Minimum Viable Product (Launch)

Week 1-2: Core Member Portal

[ ] User authentication (Devise)

[ ] Membership tiers and signup

[ ] Stripe integration (subscriptions)

[ ] Basic dashboard

Week 3-4: Booking System

[ ] Room/desk booking interface

[ ] Calendar view

[ ] Conflict detection

[ ] Booking confirmations (email)

Week 5-6: Access Control

[ ] Integrate Latch API

[ ] Grant/revoke access based on membership

[ ] Access logs

[ ] Mobile unlock (via Latch app initially)

Week 7-8: Admin & Polish

[ ] Admin dashboard (analytics, member management)

[ ] AI chatbot (basic Q&A)

[ ] Automated emails (welcome, invoice, etc.)

[ ] Testing and bug fixes

Phase 2: Smart Building (Month 3-6)

[ ] Home Assistant setup

[ ] Occupancy sensors installation

[ ] Smart lighting integration

[ ] Climate control automation

[ ] Integration between HA and Rails

Phase 3: Advanced AI (Month 6-12)

[ ] Member matching (skills, interests)

[ ] Predictive analytics (occupancy, usage patterns)

[ ] Personalized environment adjustments

[ ] Community event suggestions

[ ] Productivity insights

11. Total Technology Costs

One-Time Hardware

Total Hardware

~$4,500

Monthly Software/Services

Total Monthly

~$730

*Assuming $7K monthly revenue, Stripe fees ≈ $210

Annual Licenses

Total Annual

~$115

Total First-Year Technology Costs: ~$4,500 (hardware) + $8,760 (monthly × 12) + $115 (annual) = ~$13,400

Ongoing: ~$730/month or $8,760/year

12. Security & Privacy

Data Protection

GDPR/Privacy Compliance:

Clear privacy policy

Member data encrypted at rest (Rails + PostgreSQL encryption)

Secure access logs (who entered when, but private)

Allow members to export/delete their data

No sharing member data without consent

Application Security:

Rails security best practices (strong params, CSRF protection)

Regular dependency updates (Bundler audit)

Secure API keys (ENV variables, never committed)

HTTPS everywhere (Let's Encrypt SSL)

Rate limiting (Rack::Attack)

Physical Security:

Cameras on exterior (deter break-ins)

Smart locks log all access

Interior cameras optional (privacy concerns - ask members)

Secure server/network equipment in locked closet

Backup Strategy

Database Backups:

Render automatic daily backups (included)

Weekly manual backup to S3 (extra safety)

Code:

GitHub (already version controlled)

Physical Space:

Member data not stored locally (all cloud)

Smart home hub (Home Assistant) backup weekly

13. Support & Maintenance

Member Support Workflow

1. First Line: AI Chatbot
- Handles 80% of common questions
- Available 24/7 in member portal

2. Second Line: Issue Ticketing
- Member reports issue via chatbot or form
- Creates ticket in your admin dashboard
- You get notification (email/SMS)
- You respond or fix

3. Escalation: Direct Contact
- If chatbot can't help, member can email/call you
- Aim for <2 hour response time during business hours

Maintenance Schedule

Daily:

[ ] Check for new member signups (automated)

[ ] Review access logs (automated report)

[ ] Monitor for critical issues (Honeybadger alerts)

Weekly:

[ ] Review open support tickets

[ ] Check building systems (HVAC, coffee, cleanliness)

[ ] Review analytics (occupancy, revenue, churn)

[ ] Engage with Slack community

Monthly:

[ ] Review financials (MRR, expenses, profitability)

[ ] Member survey (NPS, feedback)

[ ] Plan community events

[ ] Software updates and security patches

Quarterly:

[ ] Strategic review (what's working, what's not)

[ ] Major feature releases

[ ] Deep clean and maintenance

[ ] Refresh amenities (new coffee, supplies)

Summary

You're building:

Rails + Hotwire for web/mobile member portal

Stripe for payments

Latch for smart access

Home Assistant for IoT/smart building

Claude API for AI chatbot

UniFi for network

Various SaaS tools for email, SMS, monitoring

Your unique advantages:

You can build most of this (save $$$)

Rails expertise means rapid development

AI integration is your differentiator

You own the property (no landlord dependencies)

Timeline:

MVP: 8 weeks of focused development

Launch-ready: 12 weeks (with build-out in parallel)

Advanced features: Ongoing, iterate based on member feedback

Next step:
Start with member portal (authentication + Stripe + basic booking). Get that working, then layer on smart access, then IoT, then advanced AI features.

Build incrementally. Ship fast. Iterate based on real usage.