NorthernGo — build apps, systems and e-commerce with AI, no code required
NorthernGo is an AI-driven development engine that builds production-ready web applications, full-stack systems, games and e-commerce stores. Describe your idea in plain text, speak it out loud or upload a sketch, and three specialised AI agents — Architect, Builder and Critic — design, write and review the code. Every app gets a Supabase database, user authentication, a deployment subdomain and compiles into an installable Progressive Web App.
Local AI, private by default
Generation can run entirely on your own GPU in the browser through WebGPU. The model weights are downloaded once and cached; after that your prompts and your code never leave the machine, and there is no per-token cost. You can also point NorthernGo at your own Ollama instance. Cloud generation is available when you want a larger model, and it is metered per plan.
Core capabilities
- AI-generated source code from a three-agent pipeline (Architect, Builder, Critic)
- Automatic Supabase PostgreSQL database in every generated app
- Built-in email and password authentication with GDPR account deletion
- Unlimited local AI generation in the browser via WebGPU
- Connect your own Ollama instance for local generation
- PWA compilation and a dedicated subdomain for every app
- Built-in transactional email engine
- Webhooks and native integrations (Zapier, Make, Fortnox)
- Headless Shopify e-commerce integration (Pro)
- Automated SEO audits for deployed apps (Pro)
- Full source code export as a ZIP of standard HTML, JavaScript and Tailwind
Plans and pricing
- Free — 0 SEK / $0 per month: 5 cloud generations per month, plus unlimited private local AI execution via WebGPU. Start building instantly.
- Premium — 179 kr / $19 per month: 25 cloud generations per month, unlimited saved projects, and full project export as ZIP files.
- Pro — 299 kr / $29 per month: 50 cloud generations per month, full Shopify integration, automated SEO audits, webhooks and Fortnox support, and deployment to custom domains.
Guides
Step-by-step documentation for building, connecting and shipping apps. Guides
Glossary
Plain definitions of the terms used across AI-assisted development. Glossary
Comparisons
How NorthernGo differs from other AI app builders. Comparisons
Frequently asked questions
What can I build with NorthernGo?
You can build working web applications without writing code. In the cloud it suits CRMs, landing pages, dashboards, portfolio sites, internal tools and forms. The AI generates clean Vanilla JavaScript and Tailwind CSS, which compiles into a fast PWA from day one. It works best for self-contained apps built from scratch rather than large existing systems.
Locally the models are much smaller. Stay with simple pages, forms and small changes, or read “What can the local models do”.
Why choose NorthernGo over other AI builders?
NorthernGo gives you standard code without locking you into a closed ecosystem. Most platforms push you into frameworks that are hard to move away from. NorthernGo generates plain Vanilla JavaScript and Tailwind CSS that you own entirely. We are also the only app builder we know of that runs generation locally on your own device via WebGPU, rather than only on someone else's servers.
Which AI models does NorthernGo use to generate code?
In the cloud, NorthernGo runs on Gemini 3.7 Flash (Google) for code, architecture and image analysis.
Locally in your browser via WebGPU (quantised, 3–9 billion parameters — not in the same class as the cloud model):
• Qwen 3.5 (4B) — the default on Free and Premium. For small, clearly described pages, forms and simple changes. Not for a first CRM or a multi-view app.
• Qwen 3.5 (9B) — Pro. The largest of the local models. Slightly better than 4B on longer instructions. Still far from the cloud model.
• Qwen 2.5 Coder (7B) — Pro. Code-tuned. Often the most reliable of the local set on HTML and JavaScript.
• Llama 3.1 (8B) — Pro. A general 8B model in the same class as the others — not a reasoning leap over the cloud.
• Ministral 3 Reasoning (3B) — Pro. Smallest and fastest to load. Weakest of the set; use when memory is tight.
You can also point NorthernGo at your own Ollama instance and run an instruction-tuned chat model you have already pulled. Embedding models, vision-only models and anything that cannot follow a code-generation prompt will not work.
The local models are open weights from Alibaba, Meta and Mistral. NorthernGo does not train its own models — what we build around them is the patch engine and in-browser syntax checks. There is no LLM critic rewrite on the local path.
What can the local models do, and what can they not do?
Worth being straight about, because the gap is real.
A quantised model with 3–9 billion parameters on your own GPU is not comparable to Gemini in the cloud. That gap does not disappear because the engine around it is good. The default on Free and Premium is Qwen 3.5 4B — the model most people will actually run.
Works well locally:
• Self-contained apps from scratch — landing pages, forms, simple pages and small tools
• HTML, CSS, Tailwind and plain JavaScript
• Boilerplate and standard patterns
• Small, clearly described changes to an app you already have (copy, colour, an extra field)
Works poorly or not at all locally:
• A first draft of a CRM, shop or dashboard with several views — the 4B model often produces a polished first screen and an unfinished third
• Apps that do not fit the model's fixed context window (often 4–8 thousand tokens on WebGPU)
• Deeper debugging of bugs that are not visible directly in the code
• Architecture and state that must stay in sync across several views
• Long, compound instructions with many conditions at once
Our recommendation: do the first structural pass in the cloud. Then iterate locally on bounded changes — unlimited runs, zero cost per generation, and the prompt stays on the machine. Switch back to the cloud for the next genuinely structural step. You can switch mid-project.
What hardware do I need to run the AI locally?
You need a browser with WebGPU and enough free video memory (or unified memory) for the model you pick. NorthernGo checks that WebGPU exists. It does not measure VRAM or pick a model for you — if the weights do not fit, loading fails.
Rule of thumb for the quantised models we ship:
• Ministral 3 Reasoning (3B) — around 3–4 GB free
• Qwen 3.5 (4B) — around 4 GB free
• Qwen 2.5 Coder (7B) and Llama 3.1 (8B) — around 6 GB free
• Qwen 3.5 (9B) — around 7 GB free
The 4B model often runs on a current laptop, including Apple Silicon, via unified memory. The 7–9B models usually want a dedicated GPU with several gigabytes free; on integrated graphics they may refuse to load or run slowly enough that a cloud round trip would have been faster. Phones are not a practical target — the product warns before you start. If loading fails, use a smaller model or switch to the cloud.
How large is the model download, and does it happen every time?
The model weights are downloaded once and then cached in the browser. The next time you build, the model starts from cache with no download.
Size depends on the model: about 2.2 GB for Ministral 3B up to about 5.5 GB for Qwen 3.5 9B. The first download therefore takes a while on a slow connection.
After that, generation itself can run without a network. Saving a project, publishing, and the database in a generated app still need the internet. If you clear browser storage the cache is lost and the model is downloaded again.
Which browsers support local generation?
Local generation is built on WebGPU. In practice that means current desktop Chrome, Edge and other Chromium browsers. Safari on recent macOS can work. Firefox support varies by version and platform.
Phones are not recommended even when WebGPU is present — these models are several gigabytes. The editor warns before you start on mobile.
If the browser has no WebGPU, NorthernGo says so and you use cloud mode instead. Everything else in the platform works either way.
Who owns the code?
You own the generated code 100%. NorthernGo is not a locked-in platform. We generate raw, standard code. You can copy it straight from the editor on any plan. Premium and Pro users can download the whole project as a standalone ZIP, and Pro users can also push it directly to a GitHub repository — either way, you host it wherever you want.
Am I locked into NorthernGo, or can I export my app?
You are never locked in. Premium and Pro users can export their entire app as a standard ZIP file containing plain Vanilla JavaScript and Tailwind CSS. Pro users can additionally push the project straight to a GitHub repository. The exported code is fully standalone, automatically configured with your project ID, and ready to be hosted anywhere.
Are the generated apps responsive, and do they work on mobile?
Yes, apps generated with NorthernGo are responsive and mobile-friendly from the start. Built with Tailwind CSS, the layouts adapt to smartphones, tablets and desktops. To enable full Progressive Web App (PWA) features and publish live, you first create and configure the subdomain in the project settings.
Can I generate an app from an image or sketch?
Yes, Pro users can build source code directly from sketches or reference images. Upload a picture or a design layout in the prompt area and the AI agent team analyses the image and generates a matching layout and functionality. Image analysis runs in the cloud, not locally.
Can I upload documents like PDFs or Word files to guide the AI?
Yes, you can upload project requirements directly. Pro users can upload PDFs, Word files (.docx) or plain text files (up to 10 MB). The AI agent team analyses the text to understand your requirements and builds your system based on that documentation. Document analysis runs in the cloud, not locally.
Contact support: support@northerngo.com
The interactive AI development environment requires JavaScript. Enable it and reload the page to start building.