Working with Electron?

Electron app failing to ship? We fix it.

Most Electron apps that reach us build fine on the original developer's laptop and nowhere else. The signing cert is missing, notarization keeps getting rejected, or the installer is a quarter of a gigabyte. We get the build pipeline working and the download sized sensibly.

  • Since 2015Fixing technology
  • FreeEstimates
  • US teamReal engineers

electron-builder.log

still failing

What it is

Electron at a glance

Electron is a framework for building cross-platform desktop apps with web technologies, bundling Chromium, Node.js and the V8 engine into a single installable program. It was originally created at GitHub for the Atom editor in 2013, then open-sourced under the MIT license, and now lives under the OpenJS Foundation.

It is the engine behind Visual Studio Code, Slack, Discord, Figma desktop, Microsoft Teams, 1Password, Obsidian and Notion, which gives a sense of what it can be pushed to. Releases track Chromium's cadence on an eight-week major release line, and electron-builder and electron-forge are the common toolchains for packaging, signing and publishing updates.

Type
Cross-platform desktop app framework
First released
2013 as Atom Shell
License
MIT, free and permissive
Maintained by
The OpenJS Foundation
Typically used for
Cross-platform desktop apps, developer tools, communication apps, note-taking apps, companion apps

The honest version

Electron pros and cons

No technology is all upside. This is where Electron earns its place and where it tends to cause trouble.

Where Electron is strong

  • One codebase for three platformsThe same web stack, Chromium with Node, produces builds for Mac, Windows and Linux without rewriting the UI three times.
  • The whole npm library is yoursAny Node package on the registry is available inside the app, which is why features that would be weeks of native work are often a day of wiring.
  • Debugging you already knowChrome DevTools is built in, so the same tools used for a website apply to the shipped desktop product.
  • Packaging and updates are solvedelectron-builder and electron-forge handle installers, code signing hooks and the auto-update feed that users never have to think about.
  • Proven at serious scaleVS Code, Slack, Discord, Figma desktop, Obsidian, Notion and 1Password all run on it, which answers most questions about whether it is production ready.

Where Electron bites

  • Every app ships its own ChromiumThe base runtime is north of seventy megabytes before a line of your code is added, so installers are large compared with a native build.
  • Memory use is noticeableEach window is a browser process with its own renderer, and users on older machines feel the difference against a native Cocoa or WinUI app.
  • Auto-update is not casual to set upIt needs signed binaries, a hosted feed and matching channel configuration on both Mac and Windows, and any of those being slightly wrong makes updates silently stop.
  • Signing and notarization keep movingApple notarization rules, hardened runtime entitlements and Windows SmartScreen reputation all change, and what worked last year may fail the next release.
  • Security has to be configured rightcontextIsolation on, nodeIntegration off and a preload script that uses contextBridge is the modern baseline, and older projects almost never match it.
  • Native modules fight the release cadenceLong-tail native dependencies have to be rebuilt against each Electron version, and the ones nobody maintains eventually break the build.
  • The Mac App Store is its own targetSandboxing, provisioning profiles and allowed APIs are a different build from the direct-download version, and getting both out of one project takes real work.

Sound familiar?

Common Electron problems we fix

The Electron problems that bring people to us, and what you have once each one is fixed.

DMG size: 180MB

The installer is too big to download

The base Electron runtime is already around seventy megabytes, and shipping unused locales, source maps and node_modules on top can easily double it.

Installer trimmed by half or more

Notarization rejected: hardened runtime not enabled

Apple notarization keeps failing

Hardened runtime entitlements, missing signatures on helper binaries, or a stale Apple Developer certificate chain are the usual reasons the staple never completes.

Signed and notarized on every build

squirrel.windows exited 1

Auto-update is broken on Windows

A code signing certificate the update framework cannot read, a feed URL that returns the wrong content type, or a version number that does not advance.

Updates install quietly in the background

Renderer process exited unexpectedly

The app crashes under real use

Renderer out-of-memory, a GPU process that aborts, or an unhandled rejection in the main process that takes the whole window down.

Crashes reported with stack traces

white screen on launch

Users see a blank window on first open

A Content Security Policy that blocks the preload script, a path that works in development but not inside the packaged ASAR archive, or a renderer that throws before anything paints.

Boots cleanly on a fresh machine

nodeIntegration: true

The security model is from an older era

Renderer with full Node access, no contextBridge, remote content loaded without a content security policy, and no isolation between the web layer and the system.

Preload script with a locked-down API

electron-builder: invalid provisioning profile

The Mac App Store build keeps bouncing

A direct-download build that assumes capabilities the sandboxed build is not entitled to, or a provisioning profile that does not match the signing identity.

Two build targets, one codebase

handoff from previous developer

Nobody left knows how it builds

A release script that only runs on one person's laptop, certificates that are not in version control, and a CI pipeline that has not run in months.

Reproducible builds, documented

What we do

Electron help, from rescue to upkeep

Call us for one failed release, or hand us the whole desktop app.

Rescue
Broken release pipeline, rejected notarization, or a build that only runs on one machine. We get a signed build out the door first and tidy the pipeline after.
Signing and notarization
Apple Developer ID and notary setup, Windows code signing, entitlements and the hardened runtime, checked on every build.
Auto-update
Hosted update feed, channels for beta and stable, and the client wiring on both platforms so users never have to reinstall.
Performance and size
Trimming the installer, cutting idle memory, and finding the renderer that is holding onto half a gigabyte for no good reason.
Security review
contextIsolation, preload scripts, CSP, and the bridge between renderer and main process looked at the way an auditor would.
Takeover and Managed Tech
Inheriting an Electron app from a previous developer, documenting how it builds, then keeping releases and dependencies moving on an ongoing basis.

How it works

From first message to fixed

  1. Look Free estimate

    Tell us what's going wrong. We look at it, then tell you plainly what's wrong and what it will cost.

  2. Fix

    We fix the cause, not the symptom. If something is down, getting it back up comes first.

  3. Harden

    Backups, monitoring, updates and access, so the same problem can't quietly come back.

  4. Hand back or stay on

    You get a plain-language write-up. Or we stay on for hosting, upkeep and new work.

Often found together

Running Electron alongside something else?

We work on the whole stack, so the problem can be wherever it actually is.

Questions

Electron questions

Something else? Call+1 737 727 7327

Can you take over an Electron desktop app from a previous developer?

Yes, this is one of the most common ways Electron projects reach us. We get the project building on a fresh machine, move signing certificates into our control, document the release steps, and put the CI pipeline back together so the next release does not depend on one person's laptop.

How do we set up auto-update for Mac and Windows properly?

The short version is a hosted update feed, signed and notarized binaries on both platforms, and electron-updater configured against matching channel names. The long version is where the problems live, and we have shipped it enough times to know where each one hides.

Why does our Electron app use so much memory?

Every window is a browser process with its own renderer, so some overhead is unavoidable. The parts that are not unavoidable are renderers that keep large objects alive, extra hidden windows nobody remembers opening, and development tools shipped into production. All of those can be measured and cut back.

Can you shrink our Electron bundle size?

Usually we can cut the installer down by a significant amount. Shipped locales nobody uses, source maps left in release builds, duplicated node_modules and uncompressed assets are the common culprits. We measure before and after so the saving is visible.

How do we get our Electron app code-signed and notarized for macOS?

You need an Apple Developer ID certificate installed in the build environment, the hardened runtime with the right entitlements, and a notary workflow that staples the ticket to the app after Apple approves it. We set this up end to end and wire it into continuous integration.

How much does Electron help cost?

Estimates are always free of charge. Describe the app and what is going wrong and you get a price before any work starts.

Free estimate

Electron build giving you trouble?

Tell us what you're running and what's going wrong. A person reads it and comes back with an estimate.

  • No charge to find out what it will take
  • If it's urgent, say so

Replies come from a person. By sending, you authorize us to email you back. No marketing.