What we shipped before this blog existed

We've been working on WebDIY for a while now, but we haven't had a proper place to write about what we're building.

That changes with this blog.

Over the past few months, we've shipped quite a few things. What started with generating and publishing web applications has grown into a platform where you can build, test, deploy, and manage your projects without having to set up all the infrastructure yourself.

We've added databases, authentication, custom domains, team collaboration, different AI models, and a lot of smaller improvements that make the experience better.

Since this is our first product update on the blog, I thought it would be useful to bring everything together in one place.

Here's what you can do with WebDIY today.

Build an app by describing what you want

The main idea behind WebDIY is pretty simple: you describe what you want to build, and WebDIY helps you turn it into a working web application.

You don't need to start by choosing a framework, setting up a repository, or configuring a development environment.

You can explain your idea in the chat, answer a few questions about who the application is for and how it should work, and let WebDIY start building.

You can then ask for changes just as you would when working with a developer.

We've made quite a few improvements to how this works.

WebDIY can now test your application in the Preview, clicking through pages and interacting with elements to check whether things are working. You can see the steps it takes and the results.

You can also attach images, PDFs, and text files to your messages. This is useful when you have a design reference, requirements document, or existing content you want WebDIY to work with.

And because projects can involve long conversations, we've added a way to keep chats going without losing the earlier context.

We've also spent time improving reliability. Project files are saved as they're written, interrupted messages can be recovered, and stalled responses can retry automatically.

There are smaller conveniences too, like saving unfinished messages so you can come back to them later, even from another tab.

These might not be the most exciting features to announce individually, but they make a difference when you're spending time building something.

Preview, edit, and rewind your work

Writing code is only part of building an application. You also need to see what it does, make adjustments, and sometimes undo changes that didn't work out.

WebDIY gives every project a live Preview where you can interact with the application while you're building it.

We've worked on making that Preview faster and less disruptive. When your app is updating, the previous view stays visible instead of disappearing into a loading screen. And when an application supports it, code changes appear without a full page reload.

You can also switch between Preview and Code to inspect or edit your project's files directly.

In October, we introduced a dedicated Tools tab to bring project management into one place.

That's where you'll find publishing, domains, logs, databases, authentication, secrets, integrations, project history, and other settings.

One feature I particularly like is History and Rewind.

Every saved version of your project appears in its history, along with information about who requested the change. If something goes wrong or you simply preferred an earlier version, you can restore your project files to that point.

We also added live server logs, which are especially useful when you're trying to understand why an application isn't behaving the way you expected.

The idea is to give you the convenience of building through AI without losing access to the tools you need when you want to look more closely at what's happening.

Publish your app without setting up hosting

One of the first major features we shipped was one-click publishing, back in July.

Once your application is ready, a project Admin can publish it directly from WebDIY.

Your app gets its own website.diy address with HTTPS, and you don't have to separately configure a hosting provider or deployment pipeline.

If your application includes a backend API built with Hono, WebDIY can publish that alongside the frontend using Cloudflare Workers.

We later added custom domains, so you can use your own domain instead of the default address.

Custom domains are available on Pro and Max, with up to 5 domains per organization on Pro and 50 on Max. You can connect a root domain, its www version, or a subdomain.

WebDIY also helps you through the DNS setup, checking individual records and showing you what still needs to be configured.

We've made the publishing experience clearer as well. You can see when a build is running and when your project has changes that haven't been published yet.

And for projects where you don't want WebDIY branding, Pro and Max plans let you turn off the "Built with WebDIY" badge.

Our goal here has been to make publishing feel like a normal part of building, rather than a separate technical process you have to figure out at the end.

Add a database and user authentication

A lot of applications need more than a frontend.

If you're building a client portal, booking system, internal dashboard, or anything that saves information, you'll probably need a database. You might also need users to create accounts and sign in.

In July, we added managed databases and authentication.

WebDIY can set up a Postgres database for your project and add email-and-password sign-up and login for the people using your app.

You don't have to create a separate database account and manually connect everything yourself.

We've since added tools to help you manage that data.

From the Database section, you can browse tables and rows, inspect schema changes, and export data as CSV. Users & Auth lets you see the accounts registered with your application.

We also added Keys & secrets, so you can securely store credentials for external services instead of putting them directly into your code.

Each project supports up to 100 secrets, and reveals are recorded.

These features have been important for moving WebDIY beyond simple landing pages and prototypes. They make it possible to build applications that store data, manage users, and interact with external services.

Build together and share your work

Not every project is something you build alone.

You might be working with a cofounder, a small team, or a client who wants to see what you're making.

We added team invitations so you can bring other people into your organization and give them different levels of access.

There are three roles: Admin, Builder, and Viewer.

Free organizations can have up to 3 members, Pro up to 5, and Max up to 10.

The Team dashboard gives you a clearer view of who has access to which projects, and the person who creates a project becomes its Admin.

We've also made it easier to share work before it's published.

You can create a temporary Preview link that lets someone open your running application without creating a WebDIY account. The link works for 7 days.

That's useful when you want to show a client an early version, get feedback from a teammate, or share something you're experimenting with.

Choose the AI model that works for you

One thing we didn't want was to tie WebDIY to a single AI model.

Different models are good at different things, and people have their own preferences about which ones they like using.

That's why WebDIY lets you choose a model for each message.

You can switch models as you work, and organization Owners and Admins can decide which models are available to their team.

As of October 23, our model lineup includes 6 options on Free, 13 on Pro, and 14 on Max.

Free uses DeepSeek V4.1 Flash by default, while Pro and Max use Claude Sonnet 5.5.

We also support bringing your own API key from Anthropic or OpenAI.

If you already have an account with one of those providers, you can connect your key and use their models without spending WebDIY credits on the model tokens. The project's development environment and other resources still consume credits.

I think having that choice matters, especially for developers who already use AI tools regularly and have a preferred setup.

Credits, plans, and billing

We've also changed quite a bit about how WebDIY handles usage and billing.

In July, we moved from message limits to credits.

Instead of counting how many messages you send, credits cover the resources your projects use, including AI-assisted building, the computer running your application during development, and hosting.

We wanted this to be transparent, so you can see how many credits each AI message consumes and review your usage across projects.

The Usage dashboard keeps 92 days of history and supports CSV exports.

Here's how the plans currently work:

If your remaining plan credits fall below 100, they're topped back up to 100 each day.

You can also buy additional credits, starting at $5 for 400 credits. Purchased credits are used after your plan credits and don't expire.

Upgrades take effect immediately, while downgrades happen at the end of the billing period. You can also switch between monthly and yearly billing from your account.

You can find the full breakdown of credits and limits in our pricing and credits documentation.

A better place to manage your projects

Alongside the bigger features, we've been working on the parts of WebDIY you interact with every day.

In October, we introduced a new dashboard that makes it easier to find recent projects, manage your team, and see what needs attention.

Deleted projects can be restored within 7 days, which is handy if something gets removed by mistake.

We've also added system theme support, so WebDIY can follow your device's light or dark mode setting.

And we've expanded account settings to include privacy requests, such as exporting your account data or requesting deletion.

A lot of these changes are relatively small on their own, but they help make WebDIY feel more complete as a place where you're managing real projects, not just experimenting with prompts.

What's next

Looking back, we've shipped quite a lot since the first version of WebDIY.

We started with the basics: describe an application, generate the code, preview it, and publish it.

Since then, we've added the tools needed to build more useful applications, manage their data, collaborate with others, and keep working on projects after they're live.

There's still plenty we want to improve, particularly around reliability, the development experience, and making more complex applications easier to build.

We'll be using this blog to share those improvements, along with some of the engineering decisions, challenges, and lessons from building WebDIY itself.

For smaller updates, you can follow our changelog. And if you'd like to keep up with future posts, you can subscribe to the RSS feed.

If you haven't tried WebDIY yet, you can start building for free. No credit card required.