Zero Downtime Hackathon | Win an NVIDIA DGX Spark AI Supercomputer
Building reliable AI systems requires three core pillars: knowing what you are building, extracting web data without breaking, and having visibility in production.
Without organization, project goals get messy. Without self-healing data, website layout changes break your app. Without monitoring, systems fail in silence.
The goal of this hackathon is to build a complete, resilient application or pipeline. You will use Port to plan your architecture, Bright Data Scraper Studio to fetch web data, and SigNoz to monitor performance.
Your projects will be judged by engineers from Anthropic!
📅 Agenda
09:00: Doors and check-in open
09:00 - 09:45: Breakfast 🥯
09:45 - 10:00: Kickoff speech
10:00 - 11:00: Workshops
11:00 - 14:00: Hacking
14:00: Pizza time 🍕
14:00 - 17:00: Hacking continues
18:00: Project submission deadline ‼️
18:00 - 19:00: Judging + networking
19:00: Winners announced
🛠️ What You Need to Build
Over the hackathon, you'll work across three layers of one system: the factory that builds software (Port), the live web data that feeds it (Bright Data), and the observability that keeps it honest (SigNoz).
1. Build the Agentic Software Factory with Port
Anyone can build a decent app in a couple of hours now. That's not a knock on Lovable, Claude Code, Cursor, or any of the other tools making it possible. It means the frontier has moved.
This hackathon asks a harder question: Can you build the factory that builds the app?
Your challenge is to create an Agentic Software Factory: an executable, repeatable, and observable system that can take a product brief or change request, assemble the right context, coordinate agents and tools, produce working software, verify the result, and keep humans in control where it matters.
You'll still ship an app. It needs to work, but it isn't the main product. We're not judging you primarily on gradients, startup potential, or how many features you squeezed into the demo. The app is the test run. The factory is the submission.
We'll be looking at:
How faithfully the factory understands the brief and its constraints
How it coordinates agents, tools, and human decisions
How it tests and verifies what it produces
How it handles failures, retries, and changing requirements
How clearly operators can see what happened and why
Whether it can run again, rather than producing one carefully rehearsed result
A single giant prompt is not a factory. Neither is a fixed CI pipeline with an LLM bolted onto it. A good factory can observe context, make decisions, act, verify the result, and adjust.
Build it your way: Use whatever models, coding agents, frameworks, cloud platforms, databases, CI/CD systems, and application builders fit your approach. Build the entire factory from scratch. Stitch together your favorite tools. You do you.
Get a head start with Port
Port is optional, but learning it before the hackathon is a pretty obvious shortcut.
Port is an agentic SDLC platform: a place to build, govern, and operate software development alongside AI agents. Its five core building blocks map closely to what a software factory needs: a Context Lake, workflow orchestration, AI agents, governance, and an interface layer that keeps humans informed and in control.
Instead of rebuilding the plumbing around every agent, you can use Port to model the factory's context, orchestrate multi-step work, define standards and approval points, track what agents touched, and give operators a live view of each run.
Port AI Builder can accelerate the Port side of your factory. Describe what you want, review the proposed plan, and use it to create or adapt the data model, relationships, scorecards, workflows, triggers, and dashboards. It does not build your application for you; it helps you build the platform and control system around the tools that do.
Your external coding agents can also connect to Port through MCP, query the same shared context, and invoke the workflows they're permitted to use. That means your agent can bring the intent while Port supplies context, execution paths, validations, and approvals.
Before the hackathon, give yourself a running start:
Read the overview of the five Agentic SDLC Platform building blocks.
Explore Port AI Builder and learn the difference between Plan and Build modes.
Connect an MCP-compatible coding agent to Port.
Prototype one small loop: brief → plan → build → test → approval → release → audit.
Don't spend the whole hackathon hunting for the cleverest model. The model is one worker on the factory floor. The interesting part is the system around it.
Bring us a working app. Show us the factory that made it possible.
🔗 Live demo to play with: demo.port.io
🎥 Intro video: Watch on YouTube
2. Fetch and Fix Data with Bright Data Scraper Studio
💰Get $50 in credits by signing up here or using code "wemakedevs" in billing section.
Every factory runs on raw material. For your agents, that raw material is live web data, and the web doesn't sit still. Pages change, layouts shift, and a scraper that worked at 2 PM can silently fail by demo time.
Your challenge is to build your web data pipeline using Bright Data directly inside your coding assistant terminal (these are just ideas, use the platform as you wish):
Extract web data through terminal commands without switching back and forth to a web browser dashboard.
Save your scraper settings inside your project rules file (like
CLAUDE.md,.cursor/rules, orCODEX.md) so your assistant reuses them automatically.Show automatic scraper repair when a target website updates its HTML structure.
We'll be looking at:
How cleanly your data pipeline lives inside your agentic workflow, not beside it
Whether your scraper configuration is reusable and version-controlled, not a one-off command
How your pipeline detects and recovers when a target site changes underneath it
Whether the data feeding your factory is fresh, structured, and actually used by your app
A hardcoded HTML parser is not a data pipeline. A good pipeline notices when the web changes, repairs itself, and keeps the factory fed.
Before the hackathon
Get set up via the Bright Data link.
Run Scraper Studio from your terminal and pull data from one site end to end.
Add your scraper settings to your project rules file and confirm your coding assistant picks them up automatically.
Break something on purpose: point at a page whose structure has changed and watch the auto-repair flow.
Don't just scrape a page once. Show us a pipeline that keeps working when the web doesn't.
3. Monitor and Observe with SigNoz
A factory you can't see inside is a factory you can't trust. If your agents plan, build, scrape, retry, and self-repair, someone needs to be able to answer: what ran, how fast, and what broke?
Your challenge is to add observability to your application or pipeline using SigNoz:
Track traces, metrics, and logs for your data pipeline and API endpoints.
Monitor performance latency, data execution rates, and failure events when scrapers break or auto-repair.
Capture execution events so you always know how your system performs under the hood.
We'll be looking at:
Whether traces, metrics, and logs cover the parts of your system that actually matter
How quickly a judge (or an operator) could diagnose a failure from your dashboards alone
Whether failure and auto-repair events show up as first-class signals, not buried log lines
How observability feeds back into the factory: alerts, retries, or human escalation
Printing to the console is not observability. A well-instrumented system tells the story of every run without you having to narrate it.
Before the hackathon
Spin up SigNoz (cloud or self-hosted) and connect a sample app.
Instrument one API endpoint or pipeline step and confirm traces are landing in SigNoz.
Build one small dashboard covering latency, throughput, and errors for your pipeline.
🏆 Prizes and Tracks
🏆 Main Grand Prize: Best Full-Stack Integration (NVIDIA DGX Spark Supercomputer worth $5,000)
This is the top prize of the hackathon! Awarded to the overall winning project that seamlessly combines Port, Bright Data Scraper Studio, or SigNoz into one complete pipeline. Using all three tools gives your team the highest chance of winning this prize.
🥇 Track Prizes (Keychron Keyboards for every member of each winning team worth $120 each)
Best Port Integration: Awarded for the clearest workspace setup showing project goals, technical choices, risk factors, and cataloged services in Port.
Best Bright Data Scraper Studio Integration: Awarded for a pure terminal workflow, proper scraper rules configuration, clean JSON output, and working auto-repair execution.
Best SigNoz Integration: Awarded for active tracing, log collection, and metric tracking across data endpoints and background jobs.
🖱️ Logitech MX Master 4 mouse for the best LinkedIn post. Make sure to tag WeMakeDevs and our sponsors.
💡 Project Ideas
Brief-to-App Factory: Drop a product brief into Port and watch a full run: workflows assemble context, coding agents connect via MCP and build the app, Bright Data Scraper Studio pulls the live web data the app needs, tests gate the output, a human approves release in Port, and every agent step is traced in SigNoz.
Self-Healing Data Product: Ship an app powered by scraped data (price tracker, job board, news digest). When a source site changes its HTML, SigNoz alerts fire, Port triggers a repair workflow, Bright Data's auto-repair fixes the scraper, and a human approves the patch. The product heals itself while you sleep.
Competitor-Watch Feature Factory: Bright Data monitors competitor changelogs and pricing pages; meaningful changes become change requests in Port; the factory drafts a spec, builds a prototype response (feature, comparison page, alert), and routes it for approval, with scrape freshness, agent latency, and retries all visible in SigNoz.
Docs-to-RAG Factory That Rebuilds Itself: Crawl a documentation site into structured data from your terminal with Bright Data Scraper Studio and ship a RAG bot. Then make it repeatable: when the docs change, Port re-runs the crawl → embed → evaluate → release loop automatically, and SigNoz streams embedding latency and answer-quality traces for every run.
Incident-to-Fix Factory: Flip the flow. A SigNoz alert (error spike, dead scraper, slow endpoint) triggers a Port workflow where an agent triages from the traces, proposes a code fix, opens a PR, and waits for human approval, with Bright Data fetching upstream status pages and release notes for context.
Feel free to build whatever you like using the sponsor tools, these are just here to spark your inspiration...! 😉
📋 Submission Requirements
GitHub repo with code, commit history, and a README that breaks down what you built. Perfect code isn't required, just ship it!
Demo Video (3 to 5 minutes): Show your terminal workflow, Port dashboard setup, live SigNoz monitoring, and the auto-fix feature working in Bright Data Scraper Studio.
🚨 Rules
Team Size: Teams must consist of 1 to 4 members.
Team Formation: You can form teams ahead of time or assemble your team on-site.
On-Site Participation: Attendance, talks, demos, and building take place in person in San Francisco, feel free to stop by throughout the day to register and jump in.
Submission Deadline: All code, READMEs, and demo videos must be submitted by the end of the day.
Follow the WeMakeDevs Code of Conduct.