How to build a startup directory website with v0
Design the directory first and let the rest follow. A grid of companies with filters, a news section and a funding page built directly from simple English descriptions, then a real database behind them with a publish rule, sign-in for the people who edit, and an admin where you add and publish everything.
v0
$ Build the screens for a startup directory (a grid of company cards with a filter sidebar and sort menu, a company page, a news list with an article page, and a funding page), then wire in a database with a publish rule, sign-in for admins, and an admin where startups, rounds and articles are added and published.
- Directory screens generated first
- Database and admin added next
- Ready to preview
Overview & core architecture
A startup directory is a hand-picked list of companies, equipped with filters to help you find them. It includes news updates to explain recent changes and funding data to show which startups are growing. Instead of letting companies submit their own profiles, everything is carefully managed and edited by admins to ensure quality.
Usually, if you want to build a directory like this, you have to rent a platform. Website builders charge a monthly fee, no-code platforms charge based on how many records or users you have, and database services charge per team member just to read the data. Most other products on the market use one of these restrictive pricing models.
This template is much simpler: it consists of a secure database and a website connected to it. The public website allows anyone to browse published startups, funding rounds, and news articles using handy filters. Meanwhile, a hidden admin panel is where your team can easily manage the companies, tags, categories, and content, and only authorized admins can make changes.
The biggest difference is how you pay. There are no limits on the number of listings, records, or users. Adding your hundredth company costs exactly the same as adding your first. Your only running costs are a database and hosting, which both offer generous free plans to start. The only real limitation is your own time: because this directory focuses on quality, everything is added manually by someone you trust, rather than being automatically pulled from a feed.
Simple database security
Our security setup basically enforces two things: the public can only see published content, and admins can manage everything. Because this security rule lives deep inside the database, a visual bug on the website can never accidentally show a draft to the public. The database simply won’t allow the private data to be loaded.
Curated instead of crowdsourced
Companies cannot automatically add themselves to the list. An admin has to create the profile, assign categories and tags, add funding data, and publish it when it’s perfect. This takes more effort than an open submission form, but it’s exactly what makes a specialized directory trustworthy and valuable to read.
Structured data instead of plain text
Funding details are saved as structured records (like stage, amount, date, and investors) rather than just paragraphs of text. The database automatically updates the company’s total funding whenever a round changes. This organized approach is what allows your visitors to easily filter startups by specific numbers and investment stages.
The parts every startup directory is built from
Six core blocks make up the platform. Start by building the main directory first to test your access rules. You can easily prompt any AI coding tool to build these components using simple language.
Filterable startup directory
A searchable grid of company cards with filters for category, funding stage, total raised, and location. Visitors can sort listings by newest additions or largest funding rounds and click any card to view full details, links, and history. Only active, published companies are visible.
News and articles
A dedicated blog section listing published stories with custom URLs, cover images, categories, and tags. Drafts remain completely hidden from the public until an admin publishes them.
Funding rounds tracker
Tracks every funding event with details on stage, amount, date, investors, and company valuation. The database automatically updates a company’s total funding whenever a round is added or changed, allowing visitors to filter by specific funding amounts.
Admin CMS for all public content
A central dashboard displaying key platform stats alongside simple management screens. Admins can add, edit, archive, or delete startups and articles, manage categories and tags, and switch user roles between admin and viewer in one click.
Secure image storage with limits
Organized storage folders with automatic file-type and size limits (5 MB for logos, 10 MB for covers and article graphics). Built-in security rules check user permissions before any file is saved to prevent unauthorized uploads.
Landing page and interactive demo mode
An engaging homepage highlighting key sectors and trends, paired with a safe demo mode. Visitors can explore the admin interface without creating an account because simulated changes are blocked from saving to the live database.
Own the directory or rent it by the month
Every product below rents you the shelf your directory sits on, and each one meters it differently: per site per month, per item in a content system, per record and app user, or per seat for data you may not republish. A directory you own has none of those meters, which is the thing to hold on to while you read the table.
Build your own
Own the directory outright: the companies, rounds and articles sit in a database you control, the site is a static build you can put on any host, and the only bills are a database plan and hosting that both start free. Your AI coding tool writes the publish rules, the admin and the funding arithmetic from a plain description.
- No meter on listings, items, records or seats, so the hundredth company costs what the first one did
- Your own filters, categories and stages, decided by you rather than picked from a builder’s menu
- Funding rounds as structured rows with totals the database keeps right, not a text field
- A publish switch enforced in the database, so a draft never leaks through a forgotten filter
- Your own domain, your own design and no builder badge in the footer
- The code and the records are yours outright, and can move to any host or any Postgres
Rent the software
Brilliant Directories · eDirectory · Webflow · Softr · DealroomRenting buys you a site this afternoon, with somebody else keeping the software patched and the servers up. What it costs is a recurring price that follows the size of the thing you built, and a ceiling you did not choose.
- Live today, with hosting, updates and support handled by the vendor
- Member accounts and payment features on the directory builders that this template does not have
- A monthly price per site, or per item, record or seat, that grows as the directory does
- Caps on records, items or app users that decide when the next tier is due
- Your design inside the builder’s theme system, and your data inside its export
- A data subscription lets you read funding rounds, not publish them as your own directory
The plainest version of renting the shelf: one directory, one price a month, whatever is in it. The lifetime plan is the closest any row comes to owning something, and it is still a licence to run your directory on somebody else’s software, with the page warning that the lifetime option is being withdrawn. Read this row for what a directory builder with member accounts and payments built in costs, because those are the two things this template does not have.
brilliantdirectories.com · checked September 2026
The row with the honest comparison in it. eDirectory sells the same software two ways, rented by the month with no cap on listings, or bought once as source you install yourself, and the second is the shape of what this guide builds. The one-time price is roughly what fourteen months of the entry plan cost, which is the arithmetic every rent-or-own decision on this page comes down to.
edirectory.com · checked September 2026
A general site builder where every company and every article is one item in its content system, so the meter is the item count and the tier is what raises it. The price is low for a small directory and the ceiling is generous, and what you are renting is the design tool and the host rather than a directory: filters, funding totals and an admin with roles are yours to assemble inside it. Monthly billing exists and shows different figures, which the page renders only once you toggle it.
webflow.com · checked September 2026
A no-code app builder priced by records and by the people who sign in, which is the meter closest to what a directory actually grows by. A real directory lands on Pro rather than Basic, because Basic caps app users and keeps the vendor’s branding on the site. The page does not say in its static text which billing basis those figures are, so read them as the monthly price at most and check the toggle before you budget.
softr.io · checked September 2026
The other thing a reader might rent instead of building: not the shelf but the data on it. Dealroom sells the funding rounds this template asks you to type in, by the seat and by the year, and what you buy is the right to read and export them, not to publish them as your own directory. Quoted in euros because that is the only currency the page offers. Read it for the scale of what somebody else’s data costs, and for why the funding tracker here is filled by hand.
dealroom.co · checked September 2026
Rule of thumb: if you want a directory this week and do not care whose software it runs on, rent one. Brilliant Directories or eDirectory will have you live before this guide is finished. If the directory is the product, or the thing that brings people to your newsletter, your fund or your community, the shelf is worth owning, because the meters above are exactly where a growing directory pays and a curated list of companies with their rounds is an asset you should be able to move, export and redesign at will. The honest middle case is a directory whose value is somebody else’s data. There the answer is a subscription, because you may read Dealroom’s rounds and you may not republish them.
Why build with v0
Skip the directory software and the server engineering. Describe the companies, the news and the funding rounds you want to track, say who may edit them, and everything a visitor sees is read from a database you own without you writing server code.
v0 starts with the screens, and the backend comes when you ask for it: the server routes and logic that read and write real data, usually once the interface already exists and there is something real to connect it to:
Sketch
Describe the screen or component you want.
Preview
See it rendered live, and select any part of it to adjust directly.
Connect
Add a database and the routes that read and write to it, once the UI needs somewhere real to save.
Iterate
Prompt again for the next screen or the next piece of logic.
The order matters here more than with a full-app builder: v0 gets you a finished-looking interface fast, and the data underneath doesn’t show up until you ask for it and give it somewhere to live.
One clickconnects a database
Supabase, Neon, and Upstash are integrations you add from the project menu once a screen needs to hold onto something real, and v0 provisions the credentials and writes the routes that use them.
Live preview is the feedback loop
Every prompt updates the working interface right there in the chat, so you see the actual screen changing instead of imagining it from a description.
Design mode edits without a prompt
Select an element in the live preview, adjust its style directly or type a plain-language instruction, and v0 applies the change back to the real source code as a new version.
Pay a developer, or do it with AI
Running a directory is practically free on starter tiers (database + host). Your only real investment is the build itself: pay for developer hours or build it faster with AI.
Hire a developer
Custom build, from scratch- Developer
- ~$9.8k-$39k
- Supabase (backend)
- Free tier · $25/mo (Pro plan)*
- Hosting
- $0 free tier
- Build time
- ~195 hrs of their work
~$9.8k-$39k for the build, then from $25/mo once the directory is live
Our ~195-hour estimate, costed against the rate survey linked below, whose bands run from a $45-$75/hr global freelance average up through $100-$150+/hr for senior US developers, before the 20-40% an agency adds, which brackets the range at roughly $50/hr and $200/hr. Most of those hours go on the admin, the publish rules and the funding arithmetic, none of which shows in a screenshot of the directory.
Build it with v0
From scratch, with v0- v0
- $0 ($5/mo of credits) to $30+/month (Plus)
- Backend (Supabase)
- Free tier · $25/month (Pro plan)*
- Hosting (Vercel)
- Free on Vercel’s Hobby plan
- Your time
- ~93 hrs
Free to try the idea, ~$30+/month on Plus while you build a real one, then whichever plan you keep using
v0 bills in dollars of credit rather than a flat fee, so cost tracks usage: importing the pre-built template can fit inside Free’s $5 a month, while a from-scratch build runs into Free’s 7-messages-a-day cap quickly and usually needs Plus, at $30 per user per month with no annual discount shown. Because v0 generates the interface and the backend as separate steps rather than one pass, expect more prompts to reach the same result than a tool that writes both together.
* On this template the free-tier lines to watch are images and the pause. The free plan includes 1 GB of file storage, and a cover or gallery image may be up to 10 MB, so a directory with a few hundred companies and their pictures reaches it. It also pauses a project after a week without activity, and a directory nobody edits for a week is normal. Pro, from $25/mo, lifts storage to 100 GB, ends the pause and keeps a daily backup for 7 days, with spend caps on by default.
Prices and rates from supabase.com, developex.com, v0.app, v0.app and vercel.com, checked September 2026.
Decide before you build
Six key choices to make before you write any code. Two affect your site’s search engine visibility, while another determines whether you manage listings yourself or let companies submit them.
Who adds a company, you or the company?
By default, only admins can add startups. This keeps the directory carefully curated, but makes you a bottleneck. Decide early if your initial version needs a public submission form with a review queue, because open submissions require extra screens, database tables, and spam management.
Does each company get its own page?
Currently, clicking a company opens a slide-over panel on the main page, meaning individual startups don’t have unique web addresses for search engines to index. Giving each company its own dedicated URL is a major structural change, so decide your SEO strategy before building screens.
Which categories, stages and tags?
Funding stages are pre-set in the database, while categories live in an admin table. However, the sidebar filters are currently hardcoded in the layout, so new admin categories won’t appear until you update the code. Decide your taxonomy early and whether filters should pull dynamically from the database.
Where does the funding data come from?
In this template, admins enter funding rounds manually and the database calculates totals. Automated data feeds or CSV imports require extra custom development, and paid data feeds usually restrict republication. Decide whether to enter data manually, import it, or leave funding out completely.
How much of the news is yours to write?
Articles currently use simple plain text with basic image and tag support, without a built-in newsletter. If publishing is a central focus, decide if you need rich text editing, multi-author permissions, or automated email sends. A regularly updated news section deserves more than a basic text box.
How big will the directory get?
Search and filters run directly inside the visitor’s browser. This is extremely fast for hundreds of companies, but fails at scale for tens of thousands. Decide your target size early so you can move filtering logic to the database and set storage limits before performance drops.
Comparing your build options
Putting a grid of company cards on a page is fast. The hard part is everything behind it: a publish rule the database enforces, funding totals that stay right when a round changes, an admin that can add, archive and delete without leaving orphans, and images that are checked before they are stored. Here are three ways to build the exact same site.
The card grid goes up in a day. The weeks go on the parts nobody sees in a screenshot: a publish switch the database enforces rather than the screen, a total that stays right when a round is edited or deleted, an admin that can archive and delete a company without orphaning its rounds and tags, and image uploads that reject the wrong file before it costs you storage.
A kit gives you a card grid, a filter sidebar and an admin table. It has never heard of a published state, a funding round or a role, so the rules that decide what a stranger can see, the totals, and the back office that keeps the two in step start from nothing.
You describe the directory in plain words and it appears in a live preview, then the database, the publish rule and the routes behind it are a second, deliberate ask. The check that matters: sign out and confirm the company you left unpublished is not in the grid the preview shows.
Estimate your exact build timeframe
Select the components you need to calculate your development timeline. Disabling unused features (like news or funding tracking) provides a faster, tailored estimate.
Your estimate
93 hrs
start to finish
Based on the 7 of 7 features you’ve selected, plus ~21h of groundwork. Toggle any on the left to watch the number move, and open the groundwork row to untick what you have already, such as a database that is already running or going live if you are only building a mock-up for now.
A rough estimate, not a quote. Real time depends on how much you customize and how clean your data is.
Let’s set up the tools you need
v0 runs entirely in the browser too, so there’s no download and no terminal. Before step 01: sign up, pick a plan, and know that a database is one click away once a screen actually needs to save something. GitHub is the last piece, and it’s what turns the chat into a project you can hand to someone else.
v0 account
Sign in with a GitHub, Google, or email account and you land in a chat where you describe the interface you want. There’s nothing to install.
Sign up for v0v0 subscription
Free includes $5 of credits a month, capped at 7 messages a day, which is fine for trying a few screens and thin for a real build. Plus is $30 per user per month, billed monthly only (v0’s pricing page shows no annual option), and it’s the realistic floor once you’re iterating past a handful of screens.
Compare v0 plansDatabase (Supabase, Neon or Upstash)
Where your project keeps its data, added when a screen needs one. v0 generates the interface first. A database is a one-click integration you add from the project menu once a screen needs somewhere real to save to, with Supabase, Neon and Upstash as the options, and connecting one lets v0 write the routes that use it.
Connect a database in v0GitHub connection
Not needed to build anything, since v0 keeps its own history of every change. Connect a repository from the chat’s Git panel and v0 also commits every code-changing message to its own branch, ready to merge as a pull request. That is the step that turns the chat into a project other tools, and other people, can use.
Connect v0 to GitHubThe database step is the one worth not skipping once your screens need real data. Everything else here takes a couple of minutes, and after that you’re just describing what you want.
Build your startup directory, one chat at a time
v0 generates the interface first and the rest when you ask, which suits this template well: the directory is exactly the kind of screen worth having in front of you early. Keep one feature to one chat so its history stays a line you can follow.
- 01
Generate the directory before anything else exists
Start with the screen visitors live on. Placeholder companies are fine, and finding out the card layout is wrong now costs nothing.
PromptSketch the directoryBuild the public screens for a startup directory: a grid of company cards with a logo, name, one-line description, category, funding stage and total raised, a filter sidebar with search, categories, funding stages, a minimum and maximum amount raised and a location field, a sort menu and a result count with a clear-all button. A company page with the full description, links and a list of funding rounds. A news list with a featured image, title, category and date per story, and an article page. A funding page listing rounds with company, stage, amount, date and investors, filterable by stage and amount. Use placeholder content for now. I will add the real database next.
Placeholder data is fine here, and only here. Everything after this step gets something real behind it.
- 02
Start a new chat for the database, the publish rule and the routes
This is the step that turns a convincing mock-up into a directory. The publish rule goes into the database here, before any admin exists, so the screens can only ever read what is published.
PromptConnect a database and design the modelIn this chat, connect a Supabase database and create the tables and the API routes behind them. Categories and tags with a name and slug. Startups with name, slug, short and long descriptions, a category, a funding stage from a fixed list (Seed, Series A through Series E+, IPO, Grant, Acquisition), a published or unpublished status defaulting to unpublished, an archived flag, logo and cover addresses, a gallery, team size, city and country, links, and total and latest funding columns. A startup_tags join table and a social links table. Funding rounds with stage, amount, date, lead investor, co-investors, valuations and notes, and a trigger that recalculates the startup’s total and latest raise on every change. Articles with title, slug, body, featured image, category, author, status and published date, and a news_tags join table. Turn on row-level security with the public half of the rules: anyone may read categories and tags, a published and unarchived startup with its rounds and links, and a published article. Make the directory, company, news and funding screens read real data through the routes, seed three companies with a round each, leave one unpublished, and show me that the directory lists two.
Ask for the routes alongside the tables. A schema with nothing reading it leaves the directory exactly as fake as it was.
- 03
Add auth and roles, checked on the server and in the database
Two layers, same rule. A route check is the first line, row-level security is the second, and it is the one that still holds when a route forgets to filter.
PromptAdd auth, roles and the admin rulesAdd authentication with email and password: a sign-in screen, logout and a session, and no public sign-up screen. Add a user_roles table with admin and viewer roles, a database function that checks a role, and a trigger that gives every new account a profile row and the viewer role. Every API route that writes must check on the server that the caller is a signed-in admin rather than trusting anything the browser sends. Then write the admin half of the access rules in the database so an admin may read, add, change and delete every row in every table, drafts included, and the database enforces the same thing the routes do. Add an admin layout that redirects anyone without the admin role to sign-in, and tell me how to promote my own account.
v0 routes run on the server, so the check belongs there. A publish rule enforced only in the component is a rule anyone can skip.
- 04
Start a new chat for the admin and the image storage
The back office is the largest screen set in the build and deserves its own chat, so restoring a version later undoes admin work without taking the directory with it.
PromptBuild the admin and the image storageIn a new chat, build the admin behind the admin layout: a dashboard with counts of startups, articles and accounts, a startups screen with add and edit dialogs, add a funding round, publish or unpublish, archive, and delete a company together with its rounds, links and tags, then screens for articles, categories, tags, and users where a role is switched between admin and viewer. Create four storage buckets (logos up to 5 MB, covers, gallery and article images up to 10 MB, image types only), readable by anyone and writable only by admins. Add a server route for logo uploads that checks the caller is a signed-in admin, checks the startup exists and the file is under 5 MB, then stores the image and writes its address to the startup. Other images upload from the admin under the bucket rules.
Be explicit that the upload route checks the role on the server. v0 will otherwise reasonably let the admin screen upload straight from the browser, since the screen already exists.
- 05
Wire the news section, then tidy the screens with Design mode
The news list and article page you sketched in step 01 get real rows, and you spend the time you save on a proper visual pass over the cards.
PromptWire the news sectionMake the news list and the article page read real articles through the routes: the list shows published articles with the featured image, title, category and date, and the article page at /news/its-slug shows the featured image and the body with its line breaks kept. Write a draft article in the admin, confirm it is invisible on the news page, publish it, and confirm it appears.
For visual fixes on the cards and the filter sidebar, select the element in the preview and use Design mode rather than describing where it sits. It is faster and it changes the real code.
- 06Destination
Add the landing page and the meta, test as a stranger, then open a pull request
The marketing page and the share cards come last, then walk the whole thing through signed out and merge, which, if that branch is the linked Vercel project’s production branch, also deploys it.
PromptAdd the landing page, demo mode, and shipAdd a marketing landing page with a hero, a sector section, a funding section, a trends section and a closing call to action, written as copy I can edit rather than pulled from the database. Give every public page a title and description and the card that shows when the link is shared. Add a demo mode switch on the sign-in screen that opens the admin with every write intercepted in the browser and a banner saying changes are not saved. Then help me walk the whole site signed out: confirm the unpublished company is nowhere, confirm an article address opens directly, confirm the admin redirects to sign-in. Once it holds up, publish and open a pull request for it.
Protecting your site: sign-in rules and secret keys
A directory has fewer security risks than complex web apps, but three key areas still require protection: admin credentials, draft content visibility, and database access keys. Here are the security rules to apply before going live.
Use your backend’s built-in authentication
Sign-in comes from the authentication service attached to your database, with a trigger that gives every new account a profile and the viewer role. The template ships a sign-in screen and no sign-up screen, so you create the first admin in the Supabase dashboard and promote it with one SQL statement. Visitors never need an account at all.
Public access restricted to published records
Database security rules dictate that unauthenticated visitors can only read categories, tags, published articles, and active startups with their funding rounds. Admins retain full access. Even if a webpage forgets to filter content, drafts won’t leak because the database refuses to return them.
Roles managed in a dedicated table
Admin status is stored in a separate roles table rather than on user profile records. A database function checks the role before the security policies run. New accounts default to a viewer role with basic public permissions, making role upgrades or downgrades simple single-row database updates.
Logo uploads checked on the server
The logo upload goes through a server-side function that confirms the caller is signed in and is an admin, checks the company exists and the file is under 5 MB, and only then uses the service key to store the image and write its address to the company. Cover, gallery and article images upload directly under the same admin-only storage rules.
Interactive demo mode without authentication
Demo mode lets visitors explore admin screens without logging in. The browser intercepts write requests locally, giving the illusion of changes without sending data to the server (where security rules would reject it anyway). Remove this feature if you prefer to keep admin screens completely private.
Remove default migrations and environment keys
The starter template includes default migration files and environment keys pointing to the original project. Delete default password reset migrations before initializing your database, replace all environment variables with your own secrets, and never hardcode credentials inside migration files.
Enable daily backups before the catalogue is worth anything
The free tier keeps no backups, so while you fill the directory your database is the only copy of every listing and round you typed in. Daily backups kept for seven days start on Supabase Pro at $25/mo. Move to it before the directory is a week of work you would not want to redo.
Review the access rules (row-level security policies) on every table. For each one, tell me in simple terms who can view, add, edit, and delete records, confirm that people can only reach their own data while the right roles can reach more, and flag anything left open that shouldn’t be.
Paste this into the chat before launch so v0 checks nobody can see data they shouldn’t.
One rule outranks everything above it: your database service key belongs on the server only, never in the app a visitor downloads and never in a repository. The publishable key is meant to be public and the access rules are what protect the data behind it, so if the service key escapes, treat it as compromised and replace it the same day.
What speeds the build, and what slows it
Speeds the build
- One screen per message, checked in the live preview before you ask for the next one
- Adding a database as soon as a screen needs to remember something, so v0 wires it up as it builds
- Clicking the thing you want changed in Design mode, rather than describing where it sits
- One feature per chat, so its history reads as a straight line you can walk back
- Sending a finished chat over to GitHub before starting the next feature, rather than stacking several together
Slows the build
- Asking for the whole app in one message instead of one screen at a time
- Building screens for data the database does not hold yet
- Describing which button to change when you could just click it
- Letting one chat run for weeks, so going back to an older version undoes everything built after it
- Approving several messages in a row without looking at the preview after each one
Connecting GitHub (Optional)
Every change in v0 is saved automatically without any technical setup. You only need to link GitHub if you want a private copy under your own control or plan to hand the codebase over to external developers.
Every message is a version
Each time a message changes your code, v0 saves it as a new version. Restoring an older one adds it back as the newest version instead of branching, so the history stays one straight line.
Versions, v0 docsUndo from the chat itself
Scroll back through the conversation and click the revert arrow on any earlier reply, or open the version number in the top right to jump straight to a specific one.
Connecting GitHub creates a real repository
From the chat’s Git panel, connect an existing repository or create one. v0 never writes straight to your main branch: every code-changing message is committed to its own working branch first.
GitHub integration, v0 docsA pull request is how it gets merged
When you’re ready, publish and open a pull request from that working branch into your base branch, review it like any other, and merge it. Starting a new chat picks up a fresh branch for the next round of changes.
This can also be v0’s deploy path
If the branch your pull requests merge into is also the linked Vercel project’s production branch, merging one triggers a production deployment. If it isn’t, the merge just follows whatever branch behavior that Vercel project is already configured with.
GitHub integration, v0 docsWhere to host your application
Hosting gives your app a home on the internet so anyone can open it via a web link. Choose a service below to make your site live. (Your database, logins, and business records are stored separately in Supabase, covered below).
| Host | Best for | Notes | Free tier |
|---|---|---|---|
| Vercel | One-click deploys | Connect the repository and every push publishes. The template already includes the routing file Vercel needs, so a shared article address opens the article rather than the home page. Hobby is for personal use only, and a directory that runs ads, sells listings or belongs to a fund is commercial, so it belongs on Pro at $20/user/mo. | Pro from $20/user/mo (Hobby is non-commercial) |
| Netlify | Drag-and-drop or Git | Drop the built folder onto the page, or link the repository, and the site is live in a minute. Accept the redirect rule Netlify offers, because without it an article link from a search result opens a not-found page. | Free tier |
| Cloudflare Pages | Readers in many countries | Serves the site from wherever the visitor is, which suits a directory whose readers are spread across the countries its startups are in. The front end is a small static folder, and the listings arrive from your database behind it. | Generous free tier |
| GitHub Pages | Not this site | Free hosting straight from a GitHub project, listed here to rule it out: the free tier requires a public repository, and the environment file naming your database sits in this project beside the code. | Free from a public repo only |
| Firebase Hosting | Teams already on Google | One command per release after a short setup, and its own config file is where the routing rewrite goes. It suits a team whose analytics and accounts already live with Google, and offers a directory nothing the others do not. | Free Spark tier |
| AWS Amplify Hosting | Teams already on AWS | Deploys from the AWS console and wants the routing rewrite before an article address resolves. Choose it when the rest of your billing already lives on AWS, since a static folder does not care where it is served from. | Free tier (build + hosting) |
| Surge | Publish from the terminal | One command from the terminal and the built folder is online, with no repository involved. Fine for showing a client the directory before launch, wrong for the address you print in a newsletter. | Free, unlimited publishing |
| DigitalOcean App Platform | DigitalOcean users | For a team already on DigitalOcean, one supplier fewer: the static folder builds and serves from the same account, beside whatever else you run there. | Free: 3 static sites, 1 GB/mo transfer |
Two things decide this, and speed is not one of them. Does the plan allow commercial use, since a directory that runs ads, sells listings or belongs to a fund is a business and Vercel’s Hobby tier is not for one. And does a link to a single article open that article for someone arriving cold, because every host here needs one routing rule for that and the template ships the Vercel version. The host serves one small static folder. Every listing comes from your database.
An empty database shows nine fictional startups, and everything you add is hidden until you publish it. The directory falls back to a built-in sample list when it finds no published companies, and every new startup and article starts unpublished, so a fresh deployment with your first ten companies typed in shows the sample companies rather than yours. Before you launch, remove the sample fallback as the README describes, publish what should be public, and open the directory in a private window to see what a stranger sees.
Keep your data in Supabase
Startups, rounds, categories, tags and articles in Postgres, four image buckets, accounts for the people who edit, and the one function that checks a logo upload before the service key touches storage.
| Service | Best for | Notes | Free tier |
|---|---|---|---|
| Supabase | Data, auth, images and the logo check | Ten tables in Postgres with the publish rule written into their access policies, accounts from its auth service, four public-read storage buckets with a size limit each, and one edge function for logos. Create a free project, hand over the URL and publishable key, push the migrations and deploy the function, and it is connected. The line to watch is file storage: 1 GB on the free plan, and a single cover image may be 10 MB. | Free tier, then usage-based |
Add AI capabilities in one simple step
Securely route your AI API keys through a lightweight serverless function. Use simple prompts to automatically draft a company profile from its website, turn a funding announcement into an article and a round, tag new listings, and write the weekly digest.
Add the one function everything else goes through
The template has no AI in it and no key anywhere, which is the right starting point: one server-side function, admin-only, with the key in its secrets and a log of what each call cost. Build this first, and every prompt below is a call to it.
Add a server-side function called ai that calls my AI provider with the key held in function secrets, never in the browser. It accepts a task name and the text or fields for that task, refuses any caller who is not a signed-in admin, records every call in an ai_calls table (who, which task, tokens in and out, a cost estimate, success or failure), and returns the model’s answer as structured fields the admin screens can fill in. Add a small usage panel to the admin dashboard showing calls and estimated spend this month.
Draft a company profile from its website
Adding a startup means typing a description, picking a category and tags, and finding the location and links. Paste the website instead and let the admin correct a draft rather than write one.
In the add-startup dialog, add a “Draft from website” button that sends the company’s homepage text to the ai function and gets back a one-line and a paragraph description, a suggested category from my categories table, up to five tags, the city and country, and any social links it found. Fill the form with the results for the admin to edit, and never publish anything automatically.
Turn a funding announcement into an article and a round
A press release is an article and a funding round in one. Pasting it once and confirming two prefilled forms is the difference between a directory that is current and one that is a month behind.
Add a “From announcement” action on the news screen that sends pasted text to the ai function and gets back a draft article (title, slug, body) and, if the text describes a raise, a funding round (stage from my stage list, amount, date, lead investor, co-investors). Show both as prefilled forms for the admin to confirm, match the article to a startup by name with a confirmation step, and leave both unpublished until the admin publishes them.
Tag and categorize listings automatically
A directory is only as filterable as its tagging is consistent, and consistency slips after the fiftieth company. Let the model suggest, and keep the admin as the one who decides.
When an admin saves a startup or an article without tags, call the ai function with the description and get back a suggested category from my table and up to five tags, preferring tags that already exist. Show them as chips the admin accepts or removes before saving, and add a “Suggest tags” button on existing records so the back catalogue can be tidied a page at a time.
Write the weekly digest
The template sends no email, so the digest lands as a draft article or a block of text you paste into whatever you send with. What it saves is the hour of gathering what happened this week.
Add a “Weekly digest” button on the admin dashboard that gathers the startups, rounds and articles published in the last seven days and asks the ai function for a short digest with a headline, one paragraph, and a bullet per raise with the amount and stage. Save it as an unpublished article and offer a copy-as-text button, since this site does not send email.
v0 doesn’t ship its own model for these prompts, so you bring an API key for whichever provider you want, and v0 writes the route that calls it. Start with a cheap model while you’re still iterating on the prompt itself, then swap in a stronger one for the version that ships, and keep every AI feature behind that one route so there’s only one key to rotate.
Get a head start with our template
None of the steps above is compulsory, because the same directory already exists, built: the filters work, the articles publish, the rounds total up and the admin runs it. Your time goes on the companies, the categories and the name on the site.
Startup Tracker
The exact startup directory this guide builds, packaged so you can open it, point it at your own backend, and make it yours from there. A directory and news site for tracking startups, the stories about them, and the funding they raise. Visitors browse and filter companies while you manage everything from an admin panel.
The key benefits of starting with a template
The directory, the news section, the funding tracker and the admin already work, with the publish rule enforced in the database. Read the security section above before you go live, because two things in the download are there to be deleted.
Building the core from scratch
~93 hrs
Opening the template, already built
~1 hr
Pay Once, Own Forever. Build exactly what your team needs without renting a monthly SaaS subscription, paying per-seat fees, or dealing with platform lock-in.
A directory that filters, already wired
Cards, search, category, stage, funding and location filters, a sort menu and the result count, all read from your database, and a company opens in a side panel with its funding history. A page per company is the decision above, and it is the one change of shape the template leaves to you.
News with a page per story
Published articles listed, and each one at its own address with a featured image, a category and tags, with drafts hidden until an admin publishes them. Bodies are plain text with their line breaks kept, so rich text is an addition rather than a given.
Funding rounds with totals the database keeps
Rounds with stage, amount, date, investors and valuations, a trigger that recalculates the company’s total and latest raise on every change, and a funding page filterable by stage and amount.
An admin with roles and 36 access policies
Startups, rounds, tags, categories, articles and users each on their own admin screen, publish and archive as switches, a dashboard with counts, admin and viewer roles in their own table, and a server-side check on every logo upload.
Two things to remove before launch
The directory falls back to nine fictional companies when your database is empty, and one migration resets the seller’s own password to a known value. Both are in the README and both are deletions rather than builds. Do them before the first stranger opens the site.
From founders who build on our templates
Finally, a template that gives you full data ownership without subscription bloat. Its clean setup makes prompting any AI tool effortless. It saved me 100+ hours of backend setup and got my directory live in several days.
Jeevan ThomasFounder & CEO, Hado.aiCommon questions
Not as shipped. Only an admin can add a company, which is what keeps the directory curated. A public submission form with a queue an admin approves from is the first decision above, and it is a real build: a table for submissions, a screen to review them, and something that stops the form filling with spam.
No. A company opens in a side panel over the directory, so no company has an address you could share or a search engine could list. If people will search for the companies by name, give each one a page, and do it before the directory fills, because it changes how the site is shaped.
From whoever runs the admin. A round is typed in with its stage, amount, date and investors, and the database recalculates the company’s total. Nothing arrives from a feed, and the data subscriptions that sell rounds do not let you republish them, so a directory built on this is filled by hand or by an import you build.
No. The template sends no email of its own, only the sign-in emails the authentication service sends, and it keeps no subscriber list. The digest prompt in the AI section drafts the week’s news as an article or a block of text, and you send it with whatever you already use.
No. You describe the tables, the publish rule, the accounts and the upload check in plain language, and your AI coding tool writes all of it. Your own job is creating a free Supabase project for it to point at, so the records and the images end up somewhere you own.
A database plan and a host, both starting free. Supabase Pro at $25/mo is worth it once the directory is a week of work you would not want to lose, because it adds daily backups, ends the free tier’s pause after a week without activity, and lifts file storage from 1 GB to 100 GB, which a few hundred companies with covers will need.
Only an admin. The database refuses to hand a draft to anyone else, whatever the screen asks for, and a startup also disappears from the public the moment it is archived. The viewer role a new account gets sees exactly what a visitor without an account sees.
Create the user in the Supabase dashboard, sign in with it once so the trigger gives it a profile and the viewer role, then promote it to admin with the one-line SQL statement in the README. Every admin after that is either created the same way or promoted from the users screen once they exist.
Yes, through demo mode. A visitor who switches it on can open the admin screens and click through them, and every save is intercepted in the browser and pretends to succeed. Nothing reaches the database. Turn it off, or remove it, if you would rather the back office stayed out of sight.
Because the template falls back to nine fictional startups when your database returns none, so the demo is never empty. Real published companies always win, and the fallback only shows when the database has none. Remove it before launch, following the README, so an empty directory shows an honest empty state.
Nothing here is proprietary. Startups, rounds, categories, tags and articles are ordinary PostgreSQL rows, and one standard dump moves all of them to any Postgres host, while the images are ordinary files in storage buckets you can download.
Yes. Each host in the table connects a domain you own and issues the certificate in a few clicks. Do it before you announce the directory, because the address is the thing people will bookmark and share.
No. You describe the screen you want in the chat and v0 generates the React and Next.js code behind it. Sign up, pick a plan, and connect a database once your screens need real data. The setup section above walks through each one.
Both, but not automatically at the same time. v0 generates the interface first. The backend (a database and the API routes that use it) is something you ask for once a screen actually needs to save or load real data.
Free plan credits reset monthly, and the 7-messages-a-day cap resets every day. If you hit either limit mid-build, what you’ve already built stays put. You wait for the reset or move up to Plus to keep going right away.
References
Sources checked September 2026- 01Pricing (monthly and lifetime plans), Brilliant Directories. brilliantdirectories.com
- 02Pricing (cloud plans and source licence), eDirectory. edirectory.com
- 03Pricing (site plans and CMS item limits), Webflow. webflow.com
- 04Pricing (record and app user limits), Softr. softr.io
- 05Pricing (Premium and Premium Plus, per seat), Dealroom. dealroom.co
- 06Pricing (Pro plan, pause, file storage, backups), Supabase. supabase.com
- 07Web developer hourly rates 2026 (freelance and agency benchmarks). developex.com
- 08Row Level Security, Supabase docs. supabase.com
- 09v0 homepage. v0.app
- 10Pricing (Plus, Business), v0. v0.app
- 11Pricing details (Free tier, credit rollover), v0 docs. v0.app
- 12Databases (connecting Supabase and others), v0 docs. v0.app
- 13Full-stack apps, v0 docs. v0.app
- 14GitHub integration, v0 docs. v0.app
- 15Deployments, v0 docs. v0.app
- 16Design mode, v0 docs. v0.app
- 17Versions, v0 docs. v0.app
- 18Pricing (Hobby plan), Vercel. vercel.com
This guide is general information. Third-party prices, plan limits and market rates are quoted from the sources above and were last checked on the date shown. Vendors change them without notice, so confirm before you budget. Build hours and the cost estimates derived from them are our own estimates, not quotes. v0 is a product of Vercel. Verify current capabilities and pricing before relying on them.