The AI Runtime - Boston

This app tracks the real-time delta between primary face-value tickets and secondary market markups across major touring events.

Display weather of a truck route, with data from the Google Maps Route Scraper and Weather Scraper on Apify

Screen the S&P 500 by risk, benchmark any company against its sector, and track how disclosed risks change over time. WealthWire turns the risk-factor section of every 10-K and 10-Q into structured, comparable data — in an interactive dashboard, Excel and CSV exports, and a JSON API.

Submit a list of domain names. One per line. The tool will get the expiry date for each and show which is expiring soon.

Trends radar of social media.

Live demo: https://bolt.new/p/68850914 Configgo Lead Radar is a lead-intelligence tool for real estate visualization companies. It turns Boston's public development filings (BostonPlans.org) into scored, prioritized leads — before competitors even know a project exists. The problem: every BD outreach call starts with 30+ minutes of manual research, and by the time a lead surfaces in press or on a developer's site, competitors have often already engaged. The insight: no single public signal (permits, press, LinkedIn) is reliable on its own — permits stall or die in zoning, press is by definition lagging, LinkedIn updates slowly. So instead of just scraping data, Lead Radar scores each lead on two axes: how early it is in the public pipeline, and how many independent sources have already picked it up. A permit filed with zero press coverage is the highest-priority, most uncontested lead — a "🔥 Fresh" flag. Once press covers it, it's "🟡 Confirmed" — still useful, but likely already being chased by other vendors. Built live during tonight's workshop using Apify's RAG Web Browser (for the live fetch + press cross-check) and Bolt for the full-stack app, with a resilient fallback to real, pre-verified Boston project data if a live call fails — so the demo never breaks even if a source hiccups mid-scrape.

This is an interactive game that you can play with your friends. Each player is given an answer and they need to write a question for that answer. At the end of each round, you vote for the question that you most laughed.

HypeIndex scrapes what the press writes and plots it against what players actually do, so you can spot who's overhyped and who's flying under the radar, before the market catches up.

LateNight Finder Find shops, restaurants, and services that are actually open right now — anywhere in the world. Search live Google Maps data, filter by "open now" against each venue's true local time, and see how many minutes until it closes. Ideal for the classic 11 PM question: "Is there a liquor store still open near me?" What it does Live Google Maps search via the Apify google-maps-scraper actor. No stale directories, no manually-curated lists. Real "open now" evaluation. Parses each place's weekly opening hours and evaluates them in the venue's local time, not the user's — so a search for "food in Tokyo" from London still returns what's open in Tokyo right now. Closes-in labels. For each open venue we compute Closes in 42 min / Closes at 11:30 PM so you know if it's worth the walk. Preset categories for the most common late-night needs — liquor, food, pharmacy, grocery, gas station, ATM, coffee — plus a free-form custom query. Server-side scraping with live progress. Apify runs stream progress back to the UI (places scraped, seconds elapsed) with a cancel button. 24-hour cache in Supabase — repeated searches for the same query and location return instantly at zero Apify credit cost.

# InterviewForge A web application that helps students and job-seekers prepare for interviews at top-tier tech companies. Browse companies, explore job tracks, view interview processes round-by-round, read practice questions with answer hints, and access curated learning resources — all in one place. ## Features - **16 top tech companies** — Google, Amazon, Meta, Apple, Netflix, Microsoft, NVIDIA, OpenAI, Uber, Salesforce, Adobe, Tesla, Spotify, Airbnb, Stripe, and ByteDance - **80 job tracks** — Software Engineering, Product Management, Data Science & AI, Design, SRE, Hardware Engineering, and more - **417 interview rounds** with acceptance rates, durations, and formats - **1,143 practice questions** tagged by difficulty (Easy / Medium / Hard) and topic, each with an answer hint - **974 curated learning resources** — YouTube channels, articles, books, and documentation links - **Interview Experiences** — users who've interviewed at a company can share their outcome, role, difficulty rating, and write-up; displayed on each company page - **Live search** — filter companies by name, tagline, or description - **Lazy loading** — data is fetched only when needed via IntersectionObserver - **Hash-based routing** — deep-linkable URLs for companies and tracks - **Responsive design** — works from mobile to desktop - **Glassmorphism dark theme** with animated gradient orbs and skeleton loading states ## Tech Stack | Layer | Technology | |-------|-----------| | Frontend | React 18, TypeScript, Vite | | Styling | Tailwind CSS 3, custom CSS (glassmorphism, animations) | | Icons | Lucide React | | Backend / Database | Supabase (PostgreSQL) | | Fonts | Inter, Plus Jakarta Sans, JetBrains Mono | ## Project Structure ``` src/ ├── App.tsx # Root component, hash-based router ├── index.css # Global styles, theme tokens, animations ├── main.tsx # Vite entry point ├── components/ │ ├── HomePage.tsx # Company grid with search │ ├── CompanyDetail.tsx # Company info + track list + experiences │ ├── TrackDetail.tsx # Interview rounds, questions, resources │ ├── ExperiencesSection.tsx # Shared interview experiences + submit form │ ├── CompanyLogo.tsx # Company initial letter in brand color │ ├── Skeletons.tsx # Loading placeholders ├── lib/ │ ├── supabase.ts # Supabase client │ ├── types.ts # TypeScript interfaces │ ├── hooks.ts # useLazyLoad, useInView hooks │ ├── icons.ts # Track icon mapping supabase/ └── migrations/ ├── 20260713233412_create_interview_prep_schema.sql └── 20260714001251_create_experiences_table.sql ``` ## Database Schema Six tables with cascading foreign keys: ``` companies 1───* tracks 1───* rounds 1───* questions └───* resources └───* experiences ``` - **companies** — name, slug, tagline, description, accent color, acceptance rate, employees, founded year, HQ - **tracks** — job track per company (e.g. Software Engineering, Product Management) - **rounds** — ordered interview steps per track with duration, format, and pass-through rate - **questions** — practice questions per round with difficulty, topic, and answer hint - **resources** — curated links (YouTube, articles, books, docs) per round - **experiences** — user-submitted interview reports per company (author, role, outcome, date, rounds count, difficulty rating, free-text write-up) Row Level Security is enabled on all tables with public read access (`TO anon, authenticated`). ## Getting Started ### Prerequisites - Node.js 18+ - npm ### Install & Run ```bash npm install npm run dev ``` The app will be available at the local dev URL Vite prints. ### Build ```bash npm run build npm run typecheck ``` ## How It Works 1. **Home page** fetches all companies from Supabase, displays them in a searchable card grid. Each card shows the company initial in its brand color, tagline, acceptance rate, employee count, HQ, and founding year. 2. **Company detail** shows the full company description and a list of job tracks. Each track has an icon and description. 3. **Track detail** displays the interview process as a timeline of rounds. Each round expands to reveal practice questions (with toggleable answer hints) and curated learning resources. 4. **Company detail** also shows an Interview Experiences section where anyone can submit their interview story (no login required) or browse what others have shared — including outcome, role, difficulty rating, and a full write-up. All data is fetched lazily — the Supabase query for a section only runs when that section scrolls into view. ## License This project is for educational purposes.

It’s a zero-friction, mobile-first web app that acts as a "Day-Of Companion" for tech events.

Finds the first few customers for your project

Track trades for Congressional people

This app generates Infrastructure as a Code for Azure IaaS and PaaS resources. Select the resource type, format and parameters. The app will generate you the template file, parameter file and deployment script. This can directly use with any deployment terminal and deploy the resource into Azure environment.

An agent that helps you make sense of your time and how to do better.

Extract complaints from reddit posts, rank based on intensity and volume and come up with business opportunities.

AI Job Finder — a web app that filters live AI/ML job postings by 10 keywords extracted from your resume (LLM, RAG, Python, LangGraph, FastAPI, Kubernetes, ML, PostgreSQL, Cloud, TypeScript), scraped in real-time via Apify's LinkedIn Jobs Scraper. Clicking a job triggers a second Apify actor that finds real recruiters/hiring managers currently at that company, with working LinkedIn profile links. Simple HTML/JS frontend + Express backend, no mock/fake data — everything shown is live-scraped

# GamePulse AI > **Your real-time command center for every game that matters.** GamePulse AI monitors live sports, detects exciting moments and tells fans what to watch, when to switch and what they missed. GamePulse AI answers one simple question: **"What is the best sports game to watch right now?"** It collects current sports data through Apify, analyzes every live or upcoming game, calculates an explainable **Watchability Score from 0–100**, and recommends the most exciting game to the user. Beyond the core recommendation, it serves as a real-time Sports Copilot and Multi-Game Command Center — tracking every live game, detecting exciting moments, telling fans when to switch, and summarizing what they missed. --- ## The Problem Sports fans often have several games competing for their attention. With multiple leagues, simultaneous matchups, and no good way to know which game is actually exciting, fans miss the best moments. GamePulse AI uses real-time sports data from Apify and an explainable excitement-ranking engine to tell fans which game is worth watching right now — and why. ## Architecture ``` ┌─────────────────────────────────────────────────────┐ │ Frontend (React) │ │ │ │ Dashboard → Hero Card → Game Cards → Game Center │ │ ↓ │ │ useGames() hook ──→ fetch /api/games │ │ ↓ │ │ Scoring Engine (client-side, deterministic) │ │ rankGames() → calculateWatchability() → sort │ │ │ └───────────────────────┬─────────────────────────────┘ │ HTTPS (no token in browser) ↓ ┌─────────────────────────────────────────────────────┐ │ Supabase Edge Function │ │ /functions/v1/games │ │ │ │ 1. Check Supabase cache (2-min TTL) │ │ 2. If miss: call Apify Actor │ │ 3. Normalize results → Game[] │ │ 4. Cache in Supabase game_cache table │ │ 5. Return { games, source, lastUpdated } │ │ 6. Fallback to demo data on any error │ │ │ └───────────────────────┬─────────────────────────────┘ │ ↓ ┌─────────────────┐ │ Apify Actor │ │ (ESPN scraper) │ └─────────────────┘ ``` ### Key Design Decisions - **All Apify calls happen server-side** in a Supabase Edge Function. The Apify token is never exposed to the browser. - **The scoring engine runs client-side** for instant recalculation (e.g., during "Simulate Live Drama"), but the score is deterministic and explainable. - **An adapter layer** (`normalizeApifyGames()`) maps the Actor's raw response to a consistent internal `Game` model, so swapping Actors only requires updating that function. - **Two-minute server-side caching** in a Supabase table prevents excessive Apify calls and keeps edge function instances stateless. ## Apify Integration GamePulse AI uses an Apify sports-data Actor to retrieve: - Live games, upcoming games, and final scores - League information, team names, and logos - Game status, start time, period/quarter/inning, and current score - Standings or team records when available - Recent sports news/headlines when available ### Environment Variables | Variable | Required | Description | |---|---|---| | `APIFY_TOKEN` | No | Apify API token. Without it, the app uses demo data. | | `APIFY_ACTOR_ID` | No | Apify Actor to run. Defaults to `parseforge/espn-sports-scraper`. | | `AI_API_KEY` | No | Optional AI key for rewriting reasons into natural summaries. | ### How to Change the Apify Actor 1. Set `APIFY_ACTOR_ID` in your Supabase Edge Function secrets to the new Actor ID. 2. Update `buildApifyActorInput()` in `supabase/functions/games/index.ts` to match the new Actor's input schema. 3. Update `normalizeApifyGames()` in the same file to map the new Actor's response fields to the internal `Game` model. The rest of the application (UI, scoring, routing) does not depend on the Actor's raw response schema. ## Watchability Score Formula The Watchability Score is a deterministic 0–100 value calculated from up to seven components: ### Live Games | Component | Max Points | Description | |---|---|---| | Closeness | 25 | How close the score is (tied = 25, ≤3 pts = 23, ≤7 = 18, etc.) | | Urgency | 20 | Late-game pressure (Q4/2nd half + low clock) | | Upset | 15 | Lower-ranked team leading | | Team Quality | 10 | Rankings or records of both teams | | Momentum | 10 | Late-game scoring shifts | | News Buzz | 10 | Number of recent headlines | | Stakes | 10 | Rivalry, playoff, or tournament significance | ### Upcoming Games | Component | Max Points | Description | |---|---|---| | Closeness | 25 | Expected competitiveness (ranking proximity) | | Urgency | 20 | How soon the game starts | | Upset | 15 | Ranking gap suggesting upset potential | | Team Quality | 10 | Rankings or records | | Momentum | 10 | Recent form (win percentage) | | News Buzz | 10 | Pre-game headlines | | Stakes | 10 | Rivalry or playoff importance | ### Personalization Bonus Users can select favorite teams, sports, leagues, and game style preferences. These add a transparent bonus (up to +12 points) to the base score. The adjustment is always shown: - Base score: 82 - Favorite-team bonus: +5 - Personalized score: 87 ### Labels | Score Range | Label | |---|---| | 80–100 | Must Watch | | 60–79 | High Potential | | 40–59 | Worth Watching | | 0–39 | Low Priority | ## Error and Fallback Behavior The application is designed to always work, even when things go wrong: 1. **No Apify token** → Returns realistic demo data with a "Demo Data" badge. 2. **Apify timeout** → Falls back to demo data. The 30-second timeout prevents hanging. 3. **Apify error** → Falls back to demo data. Error messages never expose tokens. 4. **Empty results** → Falls back to demo data. 5. **Edge function unreachable** → Client-side hook falls back to local demo data. 6. **Malformed data** → The normalization layer skips invalid entries. 7. **Cached response** → The last successful response is served from the Supabase cache table. 8. **Loading states** → Skeleton loaders appear during data fetching. 9. **Empty filter results** → A clear empty state with a refresh button. ## Demo Mode The app includes a comprehensive demo dataset with: - 6 live games across 5 sports (NBA, NFL, Premier League, MLB, NHL) - 2 upcoming games (NBA, La Liga) - A tied late-game NBA thriller (Lakers vs Celtics, Q4, 2:14) - A major upset in progress (Texans leading Chiefs at Arrowhead) - A top-ranked Premier League matchup (Man City vs Arsenal) - A low-interest blowout (Pistons vs Magic) ### Simulate Live Drama Available only in demo mode, the "Simulate Live Drama" button: 1. Advances game clocks 2. Changes scores (biased toward creating closer games) 3. Recalculates Watchability Scores instantly 4. Reorders the rankings 5. Triggers upset alerts and late-game recommendations This is essential for hackathon presentations — it demonstrates the scoring engine reacting to live game changes. ## Local Setup ```bash # Install dependencies npm install # Start the dev server (runs automatically in Bolt) npm run dev # Build for production npm run build ``` The Supabase project is pre-provisioned. The Edge Function is deployed automatically. No manual configuration is needed for demo mode — the app works fully without any API credentials. ## Hackathon Pitch > Sports fans often have several games competing for their attention. GamePulse AI uses real-time sports data from Apify and an explainable excitement-ranking engine to tell fans which game is worth watching right now — and why. ### Presentation Flow (3 minutes) 1. **Show several live games** — The dashboard loads with 6 live games across 5 sports 2. **Highlight the top recommendation** — The hero card shows Lakers vs Celtics (tied, Q4) 3. **Explain the Watchability Score** — Open the Game Center, show the score breakdown 4. **Click "Simulate Live Drama"** — Watch scores and clocks change 5. **Demonstrate a game becoming tied late** — The simulation creates late-game drama 6. **Show it move to #1** — Rankings reorder in real time 7. **Open the Game Center** — See the explainable score breakdown with radar/bars 8. **Show Apify as the real-time data layer** — The data source badge shows "Apify" 9. **Toggle Presentation Mode** — Enlarged hero card for the finale ## Future Improvements - Real-time WebSocket updates for sub-second score changes - Push notifications when a game's Watchability Score crosses 80 - User accounts with cloud-synced preferences - Historical Watchability Score trends - Social features (shared recommendations, watch parties) - Additional Apify Actors (FlashScore, official league APIs) - AI-powered natural language summaries (when AI_API_KEY is configured) - Mobile app with live widgets - Betting odds integration (display-only, no wagering advice)

test