How to build a startup directory website with Lovable
Build a working startup directory in a browser tab, message by message. A filterable list of companies, news articles with a page each, a funding rounds tracker whose totals stay right, and an admin where you publish all of it, with Lovable designing the tables and the access rules in the same chat that builds the pages.
Lovable
$ Build a startup directory website: visitors browse companies and filter them by category, funding stage, amount raised and location, read news articles about them, and see the funding rounds each one has raised. Admins add and edit startups, rounds, articles, categories and tags from a protected back office, and nothing is public until it is published.
- Directory filtering in the preview
- News and admin built
- 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 Lovable
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.
Lovable turns that work into a conversation: describe a screen or a rule in plain language and watch it appear in the live preview, in the same tab:
Prompt
Say what you want to add or change, in plain language.
Watch
The live preview rebuilds in the browser as Lovable writes the code.
Try it
Click through the real app, with real buttons, forms and data rather than a mockup.
Refine
Select what’s off and describe the fix, or ask for what’s next.
None of that requires a computer science background or writing code, and the whole build happens in one browser tab, one request at a time.
Data & backendhandled automatically
Connect your database in a single step, right from the chat. Lovable builds the tables, sets up the logins, writes the server-side functions, and turns on live updates, each one an ordinary request in plain language, not a separate tool to learn.
Click to point instead of describing where
Select any element in the live preview with Lovable’s Select elements tool, and your next message applies to exactly that piece.
Full ownership and complete privacy
The app and the records in it are yours. Every change is saved automatically, and the repository Lovable syncs to GitHub is private on every plan, with no technical setup and not one Git command.
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 Lovable
From scratch, with Lovable- Lovable
- Free (30 credits/mo) to $25+/month (Pro, from 100 credits)
- Backend (Supabase)
- Free tier · $25/month (Pro plan)*
- Hosting
- $0 on a Lovable subdomain
- Your time
- ~93 hrs
Free to try the idea, ~$25-$50+/month on Pro while you build a real one, then whichever credit tier you keep using
Lovable bills by credits, so what you pay tracks what you build: importing the pre-built template can fit inside the Free plan’s 30 credits a month, while a full from-scratch build burns through Free fast and usually needs Pro. Pro’s entry rung is $25/month (or $250/year, roughly $21/month effective) for 100 credits, the bottom of a ladder where 200 credits runs $50/month (or $500/year, about $42/month), and a multi-session build often lands on that rung or higher rather than the entry price.
* 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 and docs.lovable.dev, 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 a screen or a rule and watch the running site change in the same tab, while Lovable designs the tables and the access rules behind it. The check that matters: open the preview signed out and confirm the company you left unpublished is not in the grid.
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
Nothing gets installed, because the whole workspace is a browser tab. Three things to sort out before step 01, and a fourth worth adding once the project matters to you. After that, you build by describing what you want.
Lovable account
Nothing to download. Sign up with an email, Google, or GitHub account and you land straight in the chat where you describe what to build.
Sign up for LovableLovable subscription
Lovable bills by build credits, so the plan you need follows what you build. Free gives you 5 credits a day, capped at 30 a month, which is enough to try it rather than to finish an app. Pro is $25/month for 100 credits ($250/year, about $21/month), and that is the bottom rung: a build spread over several sessions usually lands on 200 credits at $50/month, or higher.
Compare Lovable plansSupabase project
Where your app keeps its data. Connect your own Supabase project from the chat, or let Lovable create one for you. Either way it designs the tables, adds the logins, and wires the screens to them from there.
Connect Supabase to LovableGitHub connection
Not needed to build anything, since Lovable keeps its own history of every change. Link a GitHub account and it also keeps a private repository in sync, so a copy of the real code exists outside the browser tab. Worth doing before the project is one you would hate to lose.
Set up GitHub syncOnly the first three are needed to start, and none of it touches your computer. From here, you describe what you want and Lovable builds it in the browser.
Build your startup directory, message by message
Everything below happens in one browser tab. Send a message, watch the preview rebuild, click through what changed, then send the next. One thing about the order: the tables and the publish rule come first, because a directory with nowhere real to read from is a mock-up.
- 01
Set the ground rules, connect Supabase, and design the tables
The directory cannot show anything without a database, so the database comes first here, together with the rule that decides what a stranger can see.
PromptSet the rules, connect the backend, design the tablesBefore we build anything else, note the ground rules for this project: it is a startup directory with news and a funding tracker, the vocabulary throughout is startups, funding rounds, categories, tags, articles and admins, nothing is public until its status is published and the database enforces that rather than the screen, and only an admin may add, change or delete anything. Now connect this project to Supabase, and once it is linked design the tables. 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 everywhere 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, and nothing else yet. Seed three companies with a round each, one unpublished.
Say the publish rule in the first message. Left unsaid, an assistant will reasonably filter drafts in the screen, and then a draft is one forgotten filter away from the public.
- 02
Get the directory filtering in the preview
The screen visitors live on. Cards, filters, a sort menu, a count and a view per company with its rounds, all reading real rows. Check it signed out.
PromptBuild the directory and the funding pageBuild the public directory page: a grid of company cards with the logo, name, one-line description, category, stage and total raised. Add a filter sidebar with search over name and description, categories, funding stages, a minimum and maximum amount raised and a location field, a sort menu (newest, oldest, most funded, least funded, A to Z) and a live result count with a clear-all button. A card opens a detail view with the full description, links and the rounds in date order, at an address of its own so a link can be shared. Then build the funding page: every round with its company, stage, amount, date and investors, filterable by stage and by amount, sorted by amount. Read only published, unarchived companies on both.
The preview shows two companies, not three, if the rule from step 01 holds. If it shows three, send a follow-up about the access rules before building anything else on top.
- 03
Add logins, roles and the admin gate, then check them with the audit prompt
Accounts for the people who edit, a roles table of their own, the admin half of every rule, and a back office door that only admins get through. No sign-up screen, because visitors never need an account.
PromptAdd logins, roles and the admin rulesAdd authentication with email and password: a sign-in screen, logout and a persisted 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. Write the admin half of every access rule so an admin may read, add, change and delete every row in every table, drafts included. Build an admin layout that sends anyone without the admin role back to sign-in. Then tell me how to promote my own account to admin, and show me that a viewer account sees exactly what a signed-out visitor sees.
- 04
Bookmark, then ask for the admin and the image storage
The back office is the largest screen set in the build and the one you will iterate on most. Bookmark first so a bad direction is one click back.
PromptBuild the admin and the image storageBookmark the current version first. Then 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-side function 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 directly from the admin under the bucket rules.
Expect several follow-up messages on the startups screen. Select the element in the preview to point at what should move rather than describing where it sits.
- 05
Add the news section
Articles with a page each on the public side, reading only published rows, and the articles screen you built in step 04 filling them.
PromptBuild the news sectionBuild the news section: a list of published articles with the featured image, title, category and date, and a page per article at /news/its-slug showing 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.
That last sentence is the whole publish rule tested once more, on the other table. Cheap to ask for and worth having watched.
- 06Destination
Add the landing page and the meta, try it signed out, and publish
Finish with the marketing page and the titles and share cards, look at the site as a stranger in the preview, then publish from the same tab.
PromptAdd the landing page, demo mode, and publishAdd 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 walk me through the whole thing in the preview signed out: confirm the unpublished company is nowhere, confirm an article address opens directly, confirm the admin sends me to sign-in. When it holds up, publish 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 Lovable 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 small request per message, such as a field, a screen or a rule, rather than the whole app at once
- Connecting your database before building screens that need real data, not after
- Using Select elements to point at the exact thing that should change, instead of describing its location in words
- Bookmarking a known-good version before a redesign or a change to the data model
- Reading each response before sending the next request, so small mistakes don’t stack up
Slows the build
- Asking for an entire app in one message instead of one screen at a time
- Building screens for data your database does not hold yet
- Describing which button or section to change instead of selecting it
- Skipping bookmarks, then scrolling far back through history to undo a bad change
- Approving several messages in a row without previewing what actually changed
Connecting GitHub (Optional)
Every change in Lovable 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.
What Git actually is
A recorder for a project: every change becomes a version you can go back to, and nothing is ever overwritten. GitHub is the service that keeps those versions online.
Lovable already saves every change
A new version is created each time Lovable changes your project. No save button, no Git command, and the full history is there to scroll back through.
Version history, Lovable docsReverting undoes the code, not your data
One click restores an earlier version of your code and redeploys it, but nothing already written to your database rolls back with it. A UI or logic change is safe to undo. A change that touched real records is not.
Bookmark before a big change
Before a redesign or a change to your data model, bookmark the version you are on: one click back instead of a long scroll through history.
Connecting it, if you want to
Open your project settings, pick GitHub, and authorise the account. Lovable creates a private repository and keeps it in sync both ways: changes in Lovable reach GitHub, and anything pushed to that branch comes back in. Free on every plan.
GitHub integration, Lovable docsIt’s also how you leave, if you ever want to
The synced repository is a standard Vite and React project: clone it, hand it to a developer, or deploy it yourself.
Deployment, hosting, and ownership, Lovable 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 |
|---|---|---|---|
| LovableBuilt in | Publishing from the chat | The project you have been previewing publishes itself, with nothing to configure and no account to open anywhere else. Free on any plan at a lovable.app address. Paid plans put it on your own domain: buy one through Lovable and the DNS is done for you, or point one you already own at it using the two records the setup screen shows. Certificate issued automatically either way. | Free on a lovable.app subdomain · own domain on paid plans |
One button, and the app you have been previewing is live.
Hosting it somewhere else
Only for a setup Lovable does not offer: a host you already pay for, or the exported code on your own account. None of it is needed to go live.
| 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.
You bring no key and pick no provider: Lovable manages an API key per project, and if you do not name a model it chooses one from what you describe. Match the model to the job: fast and cheap for anything that runs on every record, stronger only where the reasoning matters. Send every feature above through that one integration.
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. Everything happens in a browser tab: you describe what you want in the chat, and Lovable writes and previews the code. The setup section above covers the handful of things you connect first: an account, a plan, and your own Supabase project.
A sketch on the Free plan is fine for testing an idea, with no real backend behind it. A project connected to your own Supabase account is the one you can actually launch, with real logins, real data, and your own domain.
Build credits reset every day (Free) or on your billing cycle (paid plans). If you run out mid-session, the app you’ve built stays exactly as it is. You either wait for the reset or move up a credit tier 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
- 09Sign up, Lovable. lovable.dev
- 10Subscription plans (Free, Pro, Business), Lovable docs. docs.lovable.dev
- 11Connect Supabase, Lovable docs. docs.lovable.dev
- 12GitHub integration, Lovable docs. docs.lovable.dev
- 13Deployment, hosting, and ownership, Lovable docs. docs.lovable.dev
- 14Version history and reverting, Lovable docs. docs.lovable.dev
- 15Preview toolbar (Select elements), Lovable docs. docs.lovable.dev
- 16AI features and model selection, Lovable docs. docs.lovable.dev
- 17Custom domains, Lovable docs. docs.lovable.dev
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. Lovable is a product of Lovable Labs. Verify current capabilities and pricing before relying on them.