How to build an email signature generator with Replit
Build a signature builder in one Replit workspace, from the first message to the day the team pastes theirs. A form beside a live preview, six layouts, fonts and colours, photos hosted in storage the Agent sets up for you, a matching QR code, and clean HTML or a PNG for any mail client, published from the same tab.
Replit
$ Build me an email signature and QR code builder: a form for my details and social links, six layouts, a font and accent colour, an uploaded photo hosted at a public address, a live preview, then Copy HTML and Download PNG for any mail client. Add storage for the photos and a second tab that turns any address into a downloadable QR code.
- Storage set up in the workspace
- Form, layouts and export built
- Ready for you to publish
Overview & core architecture
An email signature generator does three basic things: it gives you a form to type your info, shows a live preview, and generates code you can paste into your email app. It also needs a small online storage space for your images.
Most companies rent signature tools and pay a monthly fee per user. In those paid tools, images load from the vendor’s servers, so signatures stop working if you cancel the subscription. Free generators don’t store anything for you. You have to upload your photos online yourself and paste the link. Every tool works in one of these two ways.
This tool is a single web page with two tabs. The “Signature” tab lets you edit details, links, and layout in a sidebar while updating a live preview next to it. You can copy the HTML code directly or save the preview as an image. The “QR” tab turns any web link into a downloadable QR code. The only server feature is a shared online storage folder where photos and QR codes live so they can load inside an email inbox.
With this tool, you pay no monthly user fees, keep full control of your image storage, and own the HTML code. However, it comes with clear trade-offs: user login and saved signatures are coded into the database but not connected to a visual interface, anyone with the direct link can upload images to the storage folder, QR codes are static, and a few design elements will not render in Gmail or Outlook.
The export is the product
A signature might look great in a browser but break in Outlook because email apps process code differently. To prevent this, our HTML applies colors, fonts, and sizes directly to every element, links to photos by web address instead of attaching them, and uses standard fonts built into every computer.
Images live at an address
Email apps do not attach images directly. They fetch them from web links. The app uploads your photos and QR codes to an online storage folder and writes those link addresses into the HTML code. This storage folder must stay active so recipient inboxes can always display your images.
One page, two tools
The signature builder and QR generator live on the same page but work independently. The QR tab creates a code in your browser that you can save as an image. Inside a signature, that same code is generated, uploaded to your online storage, and linked by web address, ensuring every email app can display it.
Essential signature builder components
Six building blocks make up the app. Get the export right first, because every layout, colour and photo only matters if it survives the paste into a mail client, and describe each block to your AI coding tool in plain words when you want it built or changed.
A five-step form beside a live preview
Details (name, title, company, email, phone, website and any custom fields you add), images, six social networks, a layout and a design step, in a sidebar you move through in any order. The preview beside it redraws on every keystroke inside a mock inbox with a To and Subject line, so you see the signature where it will actually sit, and a Done Editing view shows the finished thing with the two export buttons under it.
Six layouts from one set of details
Modern, Classic, Minimal, Professional, Creative and Compact each arrange the same fields differently: a serif with a rule above the company, a single line with dots between items, initials in a circle where there is no photo, a coloured bar down the left edge. Switching layout keeps everything you typed.
Fonts, an accent colour and drag-to-reorder
Eight fonts that ship with every operating system, so a recipient sees the one you chose, and eight accent colours applied to links and titles. In the preview, the rows of the signature can be dragged into a new order, and the order travels into the export.
Copy HTML and Download PNG
Copy HTML puts the signature on your clipboard with every style inline and the images linked by address, ready to paste into a mail client’s signature settings. Download PNG renders the preview at double resolution to a file, for a client that only takes an image. Two things in the HTML need attention before a team relies on it, and the security section names them.
Photos and QR images hosted for you
A photo or logo is checked to be an image under 5 MB, uploaded to a public storage bucket and linked from the signature by its address. Turn on the QR inside a signature and the app draws the code, uploads it the same way and links it, because a mail client only shows an image it can fetch.
A QR code generator of its own
The second tab takes any address, adds the https:// prefix if you left it off, draws the code at the highest error-correction level and downloads it as a 400-pixel PNG, falling back to SVG if the browser cannot rasterise it. The code encodes the address exactly as typed, so it works for as long as the address does and tracks nothing.
Own the signature builder or rent it by the seat
Every product below meters something: a price per person per month, a minimum head count, a fee per signature, or a subscription that keeps the images and the QR codes working. A builder you own has no meter, which is the thing to hold on to while you read the table.
Build your own
Own the tool outright: the form, the six layouts and the export are yours to change, the photos sit in a bucket you control, and the recurring bill is the storage plan, free to start and $25/mo once the images have to stay up without anyone opening the app. From a plain description, your AI coding tool produces the form, the layouts and the HTML that survives a mail client.
- No price per person, so the fiftieth signature costs what the first one did
- Images hosted at an address you control, so a signature does not go blank when a subscription lapses
- Six layouts and a design step you can change by describing the change
- HTML you can paste into any mail client, with nothing tracking who opened it
- QR codes that encode the address itself and never stop working
- Nothing to migrate away from, because the code and the bucket are ordinary and yours
Rent the software
HubSpot · WiseStamp · Exclaimer · Newoldstamp · UniqodeRenting buys you a signature this afternoon, and on the managed products somebody else installs it in every mailbox, keeps it current from your staff directory and swaps the banner under it for the next campaign. What it costs is a price per person, sometimes a minimum head count, and images that work for as long as you pay.
- Live today, with a template gallery larger than six
- Central deployment into every mailbox on the paid managers, with no pasting
- A price per person per month, and a minimum of ten on the products built for IT departments
- Free generators that host no images, so you find somewhere to put your photo first
- A signature that stops working when the subscription does, in the vendor’s own words
- Dynamic QR codes that stop redirecting when the account goes inactive
The free counterweight, and worth reading first. It is a form and an export with no account behind it, and it hosts nothing: the page tells you to put your logo somewhere else and paste in the address. That hosting is the one job this template’s backend does, and it is the difference between a generator and a builder a team can share.
hubspot.com · checked September 2026
The per-person meter in its plainest form: a platform fee per month and a dollar per employee on top, billed for the year, with the tiers priced by how much marketing machinery (campaign banners, analytics, rules) you want under every signature. The individual plan is the closer comparison for a freelancer, and even it charges for each team member added.
wisestamp.com · checked September 2026
The IT department’s version: signatures applied centrally to every mailbox, synced from your directory, with a minimum of ten seats and an annual bill. Cheap per person and the right shape for a company where nobody should be pasting anything, which is also the job this template does not do, since each person copies their own HTML.
exclaimer.com · checked September 2026
The meter is the signature itself, and the FAQ says the quiet part out loud: the images are the vendor’s, so every signature your team pasted goes blank when the subscription ends. Owning the bucket is the answer to exactly that sentence, and it is why this guide spends a security card and its launch-day warning on keeping the bucket reachable.
newoldstamp.com · checked September 2026
The QR half of the market. A dynamic code redirects through the vendor, which is what lets you change the destination later and count the scans, and it is also why the code dies with the account. The codes this template makes are static: the address is in the pixels, nobody can count the scans, and nothing can switch them off.
uniqode.com · checked September 2026
Rule of thumb: if you are one person who needs one signature today, HubSpot’s free generator will do it for nothing, provided you have somewhere to host your photo. If a whole company needs the same signature installed in every mailbox without anyone pasting anything, the managed products are what you are paying for, and this template does not do that job. In between sits most small teams: five to fifty people who want to look alike, keep their photos at an address that outlives any subscription, and hand a new hire a link rather than a seat. That is who this build is for, and the running cost is the storage plan.
Why build with Replit
Skip the design agency and the server engineering. Describe the signature you want your team to send, the layouts to choose from and where the photos should live, and the form, the live preview and the export take shape without you writing a line of HTML for a mail client.
Replit’s Agent handles the storage, the upload and the hosting from one chat, in the same workspace the app ends up living in:
Describe
Tell the Agent what to build, in plain language.
Watch
It writes the code, sets up the database, and shows the app running live.
Try it
Use the real app in the preview rather than a mockup.
Publish
Take it live on Replit’s own hosting, or ask for the next change.
The build and the place it ends up running are the same workspace throughout, so there’s no separate hosting account to set up later.
One workspacebuilds, runs, and hosts it
Replit is the one tool here that also deploys what it builds. Publishing takes the same project live on Replit’s own infrastructure, with a working domain, uptime monitoring, and security scanning included.
Managed Postgres with 20GB included free
Ask the Agent to add a database and it creates the schema and wires your app to it. What you get is a real, fully-managed SQL database rather than a mocked one.
Up to 10 Agent sessions in parallel (Pro)
Core allows up to 2 parallel Agent sessions and Pro allows up to 10, so more than one part of the app can be worked on at the same time.
Pay a developer, or do it with AI
Building a custom email signature generator involves minimal infrastructure fees (free app hosting paired with a $25/month image storage plan to keep photos active), so your primary financial choice comes down to development. Below is a side-by-side cost and time comparison between hiring a developer and building the tool yourself using AI.
Hire a developer
Custom build, from scratch- Developer
- ~$7.3k-$29k
- Supabase (storage)
- Free tier · $25/mo (Pro plan)*
- Hosting
- $0 free tier
- Build time
- ~145 hrs of their work
~$7.3k-$29k for the build, then $25/mo once the images have to stay up
Our ~145-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 HTML that has to survive three mail clients, six layouts that hold together with fields missing, and an export that matches the preview.
Build it with Replit
From scratch, with Replit- Replit
- Free (daily credits) to $25/month (Core) or $100/month (Pro)
- Database (built-in Postgres)
- Free to start · 20GB included
- Hosting (Replit Deployments)
- Billed separately, on top of the plan
- Your time
- ~69 hrs
Free to try the idea, ~$25-$100/month on Core or Pro while you build a real one, then whichever plan (plus any deployment cost) you keep using
Replit’s plan price and its credit grant are the same number, not a subscription plus a separate credit purchase: Core is $25/month for $25 of monthly credits (or $20/month billed annually), Pro is $100/month for $100 of monthly credits (or $95/month annually). Once you publish, Replit bills hosting through its own Deployments separately, on top of whichever plan you’re on. Budget for it as a second line, not folded into the $25 or $100.
* The free-tier line to watch here is the pause. Supabase Free includes 1 GB of file storage and a 5 GB monthly egress allowance, which is thousands of signature photos and a great many inbox loads, but a free project is paused after a week without activity, and a signature builder is idle by nature once everyone has pasted theirs. A paused project serves no images, so every signature already in use loses its photo. Pro, from $25/mo, never pauses and raises file storage to 100 GB.
Prices and rates from supabase.com, developex.com and replit.com, checked September 2026.
Decide before you build
Six decisions to make before writing code. Three of them are about things the template deliberately leaves out, and one is about a bucket that has to stay awake.
Do people sign in, or just use it?
As shipped, nobody signs in and nothing is saved: you make a signature, copy it and leave. The code and the database carry sign-in and a saved-signatures table that no screen uses. Decide whether a saved signature per person is worth an account, because connecting one also changes who is allowed to upload.
Who is allowed to upload an image?
Without sign-in, the rules let anyone who finds the address put an image under 5 MB into your bucket, and only an image. Fine behind a company login page, not fine on the open internet. Decide whether uploads sit behind sign-in, behind a host that asks for a password, or on a private network.
Where do the images live for the next three years?
A signature keeps loading its photo from wherever the HTML says, long after anyone opens the builder, and a free storage project pauses after a week idle. Decide now between the paid plan that never pauses, a bucket somewhere that never sleeps, or copying every image to your own website and pointing the HTML there.
Which mail clients have to be perfect?
The HTML looks right in Apple Mail and mostly right in Gmail. Outlook for Windows ignores the flex under Compact, and Gmail, Outlook and Yahoo strip the inline SVG icons. Decide which clients your recipients use, because the fix is hosted icon images and a table layout, and it is a step in the build.
Static QR codes, or dynamic ones you can change later?
The codes encode the address itself: free for as long as the address works, uncountable and unchangeable, so a printed card with a dead link stays dead. A dynamic code redirects through a service you pay to keep running. Decide whether you need to change destinations or count scans, and budget the subscription if so.
One brand, or a brand kit per client?
Six layouts, eight fonts and eight colours are one company’s options. An agency making signatures for clients wants a logo, a palette and a font per client, saved and reloaded. Decide whether the design step reads one brand or a list of them, because a saved brand is the first thing that needs an account.
Comparing your build options
Putting a form next to a preview is fast. The hard part is everything behind it: HTML that survives Gmail, Outlook and Apple Mail rewriting it, six layouts that hold together with fields missing, photos hosted at an address a stranger’s inbox can load, and a PNG that matches the preview. Here are three ways to build the exact same product.
A form with a preview beside it is an afternoon. The weeks go on what a recipient never sees: HTML that still looks right after Gmail, Outlook and Apple Mail have each rewritten it, six layouts that hold together when a field is empty, a photo that loads from an address rather than travelling as an attachment, and a PNG that matches the preview to the pixel.
A kit gives you a form, a sidebar and a colour picker. It has never heard of a mail client, a signature that has to survive a paste, or an image that must load from a public address, so the export, which is the whole product, starts from nothing.
You ask the Agent for a piece at a time and it writes the storage, the upload route and the screens in the same workspace that ends up hosting the finished app. The check that matters: copy the HTML from the published address, paste it into a mail client, and confirm the photo loads from your app on a phone.
Estimate your exact build timeframe
Plenty of useful signature builders ship with less than this. One layout, no photo upload and no QR code is still a tool a whole team can use, and a shorter build than the figure below. Untick what you are leaving out, and read the total as our own estimate rather than a quote.
Your estimate
69 hrs
start to finish
Based on the 5 of 5 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
Replit runs entirely in the browser, and it’s the one tool here that also hosts what you build, so no GitHub account is required first. Before step 01: an account and a plan. A database comes later, the moment your app actually needs one, and GitHub whenever you want a copy of the code outside Replit.
Replit account
Sign up and you land in a workspace with an Agent chat, the code, and a live preview side by side, with nothing to install.
Sign up for ReplitReplit subscription
Starter’s free daily credits are enough to try an idea, not to finish one. Core is $25/month billed monthly, or $20/month billed annually, for $25 of monthly credits and up to 2 parallel Agent sessions. Pro is $100/month monthly, or $95/month annually, for $100 of monthly credits, more collaborators, and access to the strongest available models. The price you pay and the credits you get are the same number on both plans, so you have no separate subscription-plus-credits split to work out.
Compare Replit plansReplit database (Postgres)
Every Replit app includes its own managed Postgres database with 20GB of free storage. Ask the Agent to add one and it creates the schema and connects your app to it, with no separate account to create anywhere else.
Replit’s built-in database, Replit docsGitHub connection
Not needed to start, and not needed as an undo either, because Replit checkpoints the whole workspace as the Agent works. Connect a repository from the Git pane, free on every plan, and a copy of the real code lives outside Replit under your own account. Worth doing once the project is one you would hate to lose.
Using the Git pane, Replit docsThe first two are all you need to start. Everything here stays inside the one browser tab, the app included once you publish it, and the GitHub copy is the one deliberate exception.
Build your signature builder, one Agent message at a time
Nothing installs and nothing gets connected from outside. The Agent writes the files, runs the commands, and sets up the storage as it goes. One thing to keep in mind throughout: the images every signature loads are served by your own server here, so the published app has to stay up for the signatures to keep working.
- 01
Start the app, ask for storage, and set the rules
The storage comes with the workspace, so it goes in the opening message. So do the three export rules that matter most on this build.
PromptSet up the project and the storageSet up a React 18 + Vite + TypeScript app with Tailwind and a small server of its own, and add App Storage to this Repl for uploaded images, the storage Replit provides, not anything outside. Write a short notes file at the project root saying this is an email signature and QR code builder, fixing the vocabulary as signature, layout, design, social links, QR code and export, and recording three standing rules: every style in the exported HTML is inline on the element it belongs to, layouts use tables rather than flex and fonts every operating system ships, and every image in a signature is a hosted file linked by address, never embedded. Uploads go through a server route that checks the file is an image under 5 MB before storing it, and the server serves the stored images at a public address.
The rules are worth writing into the notes file rather than a single message. Flex in the preview and inline icons in the export are both natural suggestions for any assistant, and both are holes in the signature once Outlook has it.
- 02
Build the form and the live preview
The screen you will live in. Five steps in a sidebar and a preview beside them inside a mock inbox, redrawn on every keystroke, with rows you can drag into a new order. Check the preview after each change here rather than stacking several.
PromptBuild the form and the previewBuild a single page with two tabs, Signature Generator and QR Code Generator, and start with the first. Put a five-step sidebar on the left (Details, Images, Social, Template, Design) that I can move through in any order, and a live preview on the right inside a mock inbox with a To line, a Subject line and a short confidentiality footer. Details holds full name, job title, company, email, phone, website, an optional address, a QR code address with a show toggle, and custom fields I can add and remove. Social holds LinkedIn, X, Instagram, Facebook, YouTube and GitHub. Redraw the preview on every keystroke, let me drag the rows of the signature into a new order, and add a Done Editing view that shows the finished signature with Copy HTML, Download PNG and Delete Draft buttons under it. Keep every field optional and make sure an empty field leaves no blank line behind.
This is the step where checkpoints earn their keep. A preview that was right two messages ago and is not now is a one-click problem rather than an afternoon.
- 03
Add the six layouts and the design step
The same details six ways, plus eight system fonts and eight accent colours. Every layout has to survive a missing photo and a missing phone.
PromptBuild the layouts and the design stepAdd six layouts to the Template step, each with a small preview card: Modern (name, accented title, contact lines, icons and photo in a row), Classic (a serif face with a rule above the company), Minimal (one line with dots between items), Professional (a photo or initials in a circle beside the details), Creative (a coloured bar down the left edge) and Compact (everything on two short lines). Switching layout keeps everything typed. In the Design step, offer eight fonts that ship with every operating system (Arial, Helvetica, Georgia, Times New Roman, Verdana, Tahoma, Trebuchet MS and Courier New) and eight accent colours applied to links and the job title, with a click on the chosen colour clearing it. Make every layout handle a missing photo, a missing phone and a long job title without collapsing, and show me all six with only a name filled in.
- 04
Host the images through your server, and add the QR tab
Photos and QR images stored in the workspace and served by your own route at a public address, because a mail client shows only an image it can fetch. Then the second tab.
PromptAdd uploads and the QR generatorIn the Images step, add a photo or logo upload that sends the file to a server route, which checks it is an image under 5 MB, stores it in App Storage under a random name and returns a public address the server serves it from, then puts that address into the signature with a preview and a remove button. When the QR toggle in Details is on, draw a QR code of the address in the preview, and on export draw the same code as a PNG, store it the same way and link it by address, because a mail client will not show an inline data image. Then build the QR Code Generator tab: one address field, a live code drawn at the highest error-correction level with a quiet margin, https:// added if I left the prefix off, and a Download button that produces a 400-pixel PNG with an SVG fallback. Encode the address exactly as typed, with no redirect and no tracking.
The size check is yours to write here, because there is no bucket setting doing it for you. Upload a 6 MB photo and a text file on purpose and make sure the route refuses both.
- 05
Build the export, then paste it into a real inbox
What the product actually is. Copy HTML with every style inline, hosted icon images and table layouts, and Download PNG rendered from the preview at double resolution. Then a message to yourself from a phone.
PromptBuild Copy HTML and Download PNGBuild the export. Copy HTML generates the signature for the current layout with every colour, font, size and spacing as an inline style on its element, laid out with tables rather than flex or grid, using only the eight system fonts, with the photo, the QR and each social icon as a hosted image linked by address and carrying alt text, no inline SVG anywhere, and nothing wider than 600 pixels. Store the six social icons in App Storage once and serve them from the same route. Put the result on the clipboard and confirm with a toast. Download PNG renders the preview at double resolution on a white background, waits for every hosted image to load, and downloads email-signature.png. Then tell me how to paste the HTML into Gmail, Apple Mail and Outlook, and what each one is known to strip.
Send yourself a message from a phone and open it in a second client. The preview is not the test.
- 06Destination
Decide about sign-in, then publish and check the images from outside
Accounts and saved signatures are optional. Then publish, checking who the app is visible to first, and open a sent signature on a phone, because the images now come from the published app.
PromptAdd sign-in if wanted, test, and publishTwo paths, and I will pick one. If I want accounts: add email-and-password sign-up and login with a server-side session, a signatures table in this Repl’s Postgres that saves the whole form as a row per person, a My signatures list to reload one, and make the upload route accept files only from a signed-in session. If I do not: keep the upload route open but limited to images under 5 MB, and tell me how to keep the app visible only to my team through Publishing. Either way, help me test it as a stranger: a private window, a text file and a 6 MB image that should both be refused, a signature copied and pasted into a mail client and sent to a phone. Then walk me through Publishing: which deployment type fits an app whose server does little besides store and serve images, and who it should be visible to, given that every signature will load its photo from the published address.
Keeping your files safe & secure
Simple apps often leave storage security overlooked. Review these essential access rules, public permissions, and upload limits before launching your builder.
Logins your server owns, if you add them
The shipped app has no sign-in on any screen. If the sixth step says yes to accounts, there is no hosted identity service in this workspace, so sign-up, sign-in and sessions are code on your own server rather than a product you switch on. Use a well-known library rather than writing password handling yourself, and treat the session as the thing that decides who may upload.
Images must be publicly viewable
Anyone receiving your email needs to see your photo and QR code, so these image files are intentionally visible to everyone. Do not store sensitive files (like contracts or private documents) in this storage folder, as anyone with the link can view them.
The size check is yours to write
There is no bucket setting doing it for you: the upload route has to refuse anything that is not an image under 5 MB before it stores the file, or the first oversized upload fills the storage your app depends on. Without sign-in that route answers anyone who can reach the app, which is the second decision above, and Publishing’s visibility setting is one honest answer to it.
Where the checking actually happens
Your server declares who is asking on every request, and the upload route reads that rather than trusting anything the browser sent. Two things follow. A check that lives only in the screen is skipped by anyone who talks to the route directly. And a route that checks nothing because nobody is signed in has to be the deliberate choice in the second decision, not an accident.
Email app compatibility fixes
Some email apps like Gmail or Outlook block complex graphics (like vector icons or modern web layouts), which can leave blank spaces in your signature. To ensure your signature looks right to every recipient, use standard image files (like PNGs) for social icons and test the result in Outlook.
Where your data goes (and stays private)
The personal details you type stay private inside your web browser and are never sent to external servers. The only things sent online are your uploaded photo and QR code so email recipients can view them.
Keep the app published and back up the store
The images are served by the published app, so the deployment is what every sent signature depends on, and taking it down blanks all of them. Check what your plan retains for this workspace’s App Storage before you rely on it, and keep a copy of the photos somewhere else on a schedule, because they are the one thing here that cannot be regenerated from the form.
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 the Agent checks nobody can see data they shouldn’t.
One rule outranks everything above it: the storage credentials and any AI provider key you add belong in Secrets only: never in anything the browser downloads, and never in a repository. If either gets out, treat it as compromised and rotate it the same day.
What speeds the build, and what slows it
Speeds the build
- One small, specific request per message, checked in the live preview before the next one
- Letting the Agent provision the database from the chat instead of wiring one up by hand
- Running two Agent sessions in parallel on unrelated parts of the app, once your plan allows it
- Rolling back to a checkpoint the moment a change goes wrong, instead of unpicking it by hand
- Reviewing what Publishing changed, meaning the domain, who can reach the app, and the machine it runs on, before the first release
Slows the build
- Asking for the whole app in one message instead of one piece at a time
- Building screens for data that isn’t in the database yet
- Running unrelated Agent sessions against the same files at the same time
- Letting several risky changes stack up before checking whether any of them actually broke something
- Publishing without checking who the app is visible to first
Connecting GitHub (Optional)
Every change in Replit is saved automatically without any technical setup. Checkpoints are the day-to-day undo. 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 milestone is already saved
Replit’s Agent creates a checkpoint automatically at key points as it works: a full snapshot of the files, the configuration, and even the AI conversation itself, not just the code.
Checkpoints and rollbacks, Replit docsRolling back restores the whole workspace
One click returns your project to an earlier checkpoint (files and configuration together, and optionally the database), which is broader than a typical code-only undo, so a rollback after real data has changed is worth a second look before you confirm it.
GitHub keeps a copy outside Replit
Connect a repository from the Git pane, free on every plan, and stage, commit, and push changes back to GitHub with a click, or pull in anything changed outside Replit.
Using the Git pane, Replit docsIt’s also how an existing project gets in
Point Replit at a public repository’s URL for a fast import, or use the guided import for a private one. Either way, Replit detects the stack and installs everything on its own.
Import from a provider, Replit docsYou rarely type git commands
The Git pane’s buttons cover staging, committing, and pushing. If you’d rather type them yourself, the workspace Shell stays in sync with whatever the pane just did.
Going live without external hosting
Skip third-party hosting and external storage setup. Your storage, backend, and domain live in the same Replit workspace. Just click Publish to go live.
| Host | Best for | Notes | Free tier |
|---|---|---|---|
| Autoscale | Most signature builders | Grows with traffic and shrinks to nothing when nobody is making a signature, which suits an app the whole team uses in its first week and then rarely. The server does little besides accept an upload and serve an image, so this is the cheapest shape for the build, and it stays reachable for the images every sent signature keeps loading. | Metered, billed with your plan |
| Reserved VM | A very large rollout | Dedicated compute that never sleeps, so the first image load after a quiet weekend has no cold start. Worth considering when thousands of signatures load your images all day, and more than a small team needs. | By machine size, billed with your plan |
| Scheduled | Not this app | Runs on a timer rather than answering requests, which fits nothing in this build. Nothing here happens overnight, and the images have to be served the moment a recipient opens a message. | Metered, billed with your plan |
| Static | Not this app | Files only, with no server behind them. Ruled out here, because the route that accepts an upload, checks its size and serves the stored images is the server, and none of it exists on a static deployment. | Metered, billed with your plan |
All four are Replit rather than a third party, so the choice is shape rather than vendor, and Autoscale suits most of these apps. Two things specific to this build: the server is tiny, because the HTML is generated in the browser and the only server work is storing and serving images, and those images are loaded by every recipient of every message, so the published address is what the whole team’s signatures depend on. Review who the app is visible to before that first release.
Every signature your team sends loads its photo from your published app, so taking the app down blanks all of them at once. There is no separate bucket here: the images are served by the same deployment as the builder, so an unpublished app, a lapsed plan or a renamed address turns every photo and QR code in every signature already sent into a broken image, in other people’s inboxes. Before the first colleague pastes a signature, settle the deployment and the address, then send yourself an email from a phone and check the photo loads.
Your storage is already part of the workspace
Nothing to connect. The photos and QR images live in App Storage and are served by your own server, and a database only enters the picture if you connect sign-in and saved signatures.
| Service | Best for | Notes | Free tier |
|---|---|---|---|
| Replit App Storage | The photos and QR images | Replit’s built-in object storage for uploads like images, set up by the Agent when you ask for it and backed by Google Cloud Storage. Your server route writes the checked file into it and serves it back at a public address, so the size and type check is yours to write rather than a bucket setting. A team’s signature photos are small files, and nothing here is the line to watch except that the app serving them stays published. | Billed by usage with your plan |
| Replit Postgres | Only if you add accounts | Managed Postgres with 20GB included free, provisioned from the same chat that builds the app. The shipped app saves nothing, so you need it only if the sixth step says yes to sign-in and saved signatures, and even then it holds a handful of small rows. | Free to start · 20GB included |
Add AI capabilities in one simple step
Securely connect AI features with safety controls and usage limits to protect your account. Once enabled, simple prompts let you auto-fill details from a bio, match brand colors from your logo, check email client compatibility, and instantly create matching signatures for your entire team.
Build the one function every feature goes through
The template calls no model, which means there is nothing to protect yet. Build the function before any feature below, with the key in its secrets, a log of every call and a ceiling, so the first feature inherits all three.
Create one server-side function called ai that holds my AI provider key in its secrets and never returns it. It accepts a task name and a payload, calls a current model on my provider’s price list, and returns the result. Before contacting the provider it writes a row to an ai_calls table (task, model, tokens in and out, a cost estimate, success or failure) and checks the calls so far today against a limit I can change without a deploy, and answers with a friendly “that is enough for today” instead of an error when it is reached. The limit and the cost are never accepted from the browser. Finish with a small usage panel in the app that shows calls and estimated spend this month.
Fill the form from a pasted bio or an old signature
Most people already have their details somewhere: an old signature, a profile summary, a staff page. Let a model sort a pasted block of text into the fields and leave you as the one who presses done.
Add a “Paste your details” box above the Details step. Send the pasted text to the ai function and ask for the form fields it can find (full name, job title, company, email, phone, website, address, and social profile links by network), each with a confidence. Fill the form with the results, highlight anything the model was unsure about for me to confirm, and never overwrite a field I have already typed unless I ask.
Suggest a font and accent colour from the logo
The design step offers eight fonts and eight colours. A model that has seen the logo can suggest which pairing sits closest to the brand, and say why, which is faster than trying all sixty-four.
When a logo or photo is uploaded, add a “Suggest a design” button that sends the image to the ai function with the list of the eight fonts and eight accent colours this app offers and asks for the closest pairing and one sentence of reasoning. Show the suggestion as a preview I can apply or dismiss, and never change the design without my click.
Check the export against real mail clients
The export can look perfect here and lose its icons in Gmail. A model that reads the generated HTML against a checklist of what each client removes turns a guess into a short list of fixes.
Add a “Check compatibility” action beside Copy HTML. Send the generated HTML to the ai function with a checklist of what Gmail, Outlook for Windows, Outlook.com, Apple Mail and Yahoo Mail do not render (inline SVG, flex and grid layout, web fonts, background images, images without alt text, anything wider than 600 pixels) and ask for a plain-language list of what will break where and how to fix each one. Show the list in a panel, and where a fix is mechanical, offer a button that applies it and regenerates the HTML.
Turn one signature into a set for the team
A team signature is one design and thirty sets of details. Paste a list of names, titles and phones, let a model map the columns, then generate the HTML for each person as a bundle you can hand out.
Add a “Team” tab that accepts a pasted spreadsheet or CSV of people, sends the header row and three sample rows to the ai function to map the columns onto the signature fields, shows me the mapping to confirm, then generates one signature per row using the current layout and design, with each person’s photo left as a placeholder they can replace. Offer the result as a zip of HTML files plus a PNG each, and log one ai call for the mapping only, since generating the signatures needs no model.
A cheap model is plenty for most of the prompts above. Save Pro’s stronger models for the one or two spots where the extra reasoning actually pays for itself. Add any provider key through Replit’s own Secrets tool rather than hard-coding it, and keep every AI feature behind one server-side function so a single key covers the whole app.
Get a head start with our template
None of the steps above is compulsory, because the same app already exists, built: the form, the six layouts, the live preview, the HTML and PNG export, the hosted images and the QR tab. Your time goes on your colours, your fonts, and the two export fixes the security section names.
Signature & QR Builder
The exact signature builder this guide builds, packaged so you can open it, point it at your own backend, and make it yours from there. A builder that turns your details into a polished email signature and matching QR code. Fill in the form, pick from six templates, watch it update live, then copy out clean HTML you can paste into your mail client or download it as a PNG file.
The key benefits of starting with a template
Save dozens of hours with a fully functional signature builder. Form fields, responsive layouts, live preview, cloud storage, and exports are pre-configured and ready to deploy.
Building the core from scratch
~69 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.
Six ready-to-use layouts with live preview
Choose from Modern, Classic, Minimal, Professional, Creative, and Compact designs. Each template cleanly adapts if a photo, phone number, or job title is missing. Next to the form, a realistic email preview updates in real time as you type and allows drag-and-drop section reordering.
Two built-in export options
Easily copy clean HTML code with styled text and web-linked images, or download a sharp, high-resolution PNG image directly from the preview. If your team relies on picky email apps like Outlook, simple tweaks for social icons and layout tables are available as explained in the security guide.
Image storage ready out of the box
Profile photos and QR codes are automatically checked, uploaded to a public storage folder capped at 5 MB for image files, and linked directly into your HTML. All storage settings and rules are pre-packaged in the code, making project setup quick and straightforward.
User sign-in and saved signatures pre-built
The codebase includes a login interface, profile database tables, and user access rules behind the scenes. None of these features are shown on screen yet, but you can activate accounts and connect individual storage permissions whenever you are ready.
A standalone QR code generator
The second tab creates high-quality QR codes directly inside your web browser and lets you download them as PNG files, with SVG as a fallback. It requires no user accounts, external link redirects, or usage limits, meaning printed codes remain permanent and static.
From founders who build on our templates
We launched our own team signature builder in under an hour instead of spending weeks on custom code. No per-seat subscription fees, total control over our data, and a clean HTML export that just works.
Jeevan ThomasFounder & CEO, Hado.aiCommon questions
It does, through your own server. A photo or logo you upload and the QR code drawn for a signature go into App Storage in this workspace, and the server serves them at a public address the HTML links. That is the difference between this and the free generators, which ask you to host the image first, and it is also why the published app has to stay up: the images come from it.
Mostly, with two known exceptions the security section names. The template’s social icons are drawn as inline SVG, which Gmail, Outlook and Yahoo strip, and its Compact layout uses flex, which Outlook for Windows ignores. The build above uses hosted icon images and tables instead. Every other layout is plain inline-styled HTML with system fonts and hosted images, and the test is a message sent to a phone.
Not as shipped. Sign-in and a saved-signatures table exist in the template’s code and schema, but no screen uses them: you fill in the form, copy the HTML and leave. Adding them here means a session your own server owns and a Postgres table the Agent provisions, and it also lets the upload route accept files only from signed-in people.
Anyone who can reach the app, unless you say otherwise. Because nobody signs in, the upload route answers any visitor, limited to images under 5 MB by the check you write into it. Keep the app visible only to your team through Publishing, or add sign-in and make the route accept files only from a session.
Neither. The code encodes the address exactly as you typed it, so it works for as long as the address does, and nobody, including you, can count the scans or change the destination later. A dynamic code that can do both is a redirect through a paid service, and the fifth decision above is where to weigh that.
Your Replit plan, plus App Storage and Publishing. Core starts at $25/month, or $20/month billed annually, and the deployment that serves the app and its images is billed separately on top. The storage itself is small, a photo per person, and the thing to budget for is keeping the deployment published, because every sent signature loads its image from it.
Yes. A layout is a name in the list plus the HTML it generates for the export and the preview, and the Agent adds one from a description or a screenshot of a signature you like. Keep it to inline styles, system fonts, hosted images and tables rather than flex, because the mail clients decide what survives, not the browser.
Only for a client that refuses HTML. The PNG is a picture of the preview at double resolution, so nothing in it is clickable, and some mail clients show it as an attachment rather than a signature. Paste the HTML wherever you can and keep the PNG for the one client that cannot take it.
No. Ask for storage for uploaded images and the Agent sets up App Storage in this workspace and writes the route that checks a file, stores it and serves it back. Your own job is deciding who may call that route, and putting any credentials in Secrets so only the server can read them.
Nothing beyond drawing the signature. The HTML is generated in the browser and copied to your clipboard, and your server sees your name, phone and links only if you add saved signatures. The photo and the QR image are the only two things that leave the tab, through your own server into your own storage, and the QR image encodes the address you typed.
Nothing here locks you in. Every signature is HTML on your clipboard or a PNG on your disk the moment you export it, the images are ordinary files in App Storage you can download from the workspace, and any saved signatures are rows in plain Postgres a standard dump carries anywhere.
Yes. The replit.app subdomain it starts on can be replaced with your own through Publishing, HTTPS included. Do it before the first colleague pastes a signature, because every image address in every signature carries whatever domain the app had when the HTML was copied, and changing it later means re-pasting.
No. You describe what you want in the chat, and the Agent handles the rest: the code, the database, and a live version of the app right there in the workspace. The setup section above covers the account and plan you need first.
Replit hosts it. Publishing takes the same project live on a Replit domain, or your own if you connect one, with monitoring and access controls included, so you never open a separate hosting account.
Starter’s daily credits and a paid plan’s monthly grant both refill on their own schedule. Hitting either limit mid-build doesn’t touch what you’ve already made. Move up a plan for more headroom right away, or wait it out.
References
Sources checked September 2026- 01Free Email Signature Generator (no account, images by URL), HubSpot. hubspot.com
- 02Pricing (Basic, Grow, Platform, Pro+), WiseStamp. wisestamp.com
- 03Pricing (Starter, Standard, Pro, ten-user minimum), Exclaimer. exclaimer.com
- 04Pricing (per signature, subscription FAQ), Newoldstamp. newoldstamp.com
- 05Pricing (static vs dynamic QR codes, inactive accounts), Uniqode. uniqode.com
- 06Embedded SVG image support by mail client, Can I email. caniemail.com
- 07display:flex support by mail client, Can I email. caniemail.com
- 08Pricing (Free storage and egress, pause, Pro plan), Supabase. supabase.com
- 09Web developer hourly rates 2026 (freelance and agency benchmarks). developex.com
- 10Pricing (Starter, Core, Pro), Replit. replit.com
- 11Built-in database, Replit docs. docs.replit.com
- 12Publishing overview, Replit docs. docs.replit.com
- 13Deployment types, Replit docs. docs.replit.com
- 14Checkpoints and rollbacks, Replit docs. docs.replit.com
- 15Using the Git pane, Replit docs. docs.replit.com
- 16Import from a provider, Replit docs. docs.replit.com
- 17Secrets, Replit docs. docs.replit.com
- 18App Storage (object storage for uploads), Replit docs. docs.replit.com
This guide is general information. Third-party prices, plan limits, mail-client support tables 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. Replit is a product of Replit, Inc. Verify current capabilities and pricing before relying on them.