NNabeel Hassan

Blog · November 21, 2026 · 8 min read

Shipping a Windows Desktop App: Code Signing, SmartScreen, Installers and Auto-Updates

By Nabeel Hassan — AI Engineer · ICPC World Finalist

TL;DR: Shipping a Windows desktop app or SDK is mostly not about the code. It is about trust and delivery: a code signing certificate whose key lives in hardware or a cloud signing service rather than on a laptop, a timestamp on every signature so it outlives the certificate, an installer format chosen for how you will update rather than how you will install, an update channel that ships in version one, and a plan for the first weeks when SmartScreen and antivirus engines have never seen your publisher before. I learned most of this setting up Windows CI/CD at Geonode around the Repocket C# SDK, where the code had to run quietly in the background of other people's machines. Sign in CI, timestamp everything, pick the updater first, and expect the warnings to fade with reputation rather than disappear on day one.

App stores sign, distribute, update and vouch for your app in one pipeline. Windows does not. You can put an .exe on a download link tonight, and that freedom is why the first real release surprises people. The build works. Then a user downloads it and Windows shows a blue box saying it protected their PC, their antivirus quarantines a DLL, and nobody has a way to get them the fix you shipped on Thursday.

At Geonode I built the Repocket SDK in C# for Windows, Android and iOS, and set up the Unity and Windows CI/CD pipelines around it. This is the checklist I now use for any Windows release.

Why Windows distribution is its own problem

Three things make Windows different from shipping to phones or the web.

Nobody vouches for you by default. There is no review queue that ends in a trusted listing (unless you go through the Microsoft Store, which is a valid choice I come back to below). Trust comes from your signature and from reputation that builds over time.

Downloads are marked. A file downloaded through a browser carries a "Mark of the Web", and that is what triggers SmartScreen checks when the user runs it. The same binary copied over from a USB stick behaves differently, which is why "it runs fine on my machine" proves very little.

Updating is your job. A web deploy replaces every user's version at once. A desktop app stays exactly where it was installed until something updates it. If you did not build that something, your first release is also your last for most users. I made the same argument for phones in keeping a backend compatible with old app versions, but on Windows it is worse: there is not even a store nagging people to update.

Code signing: what it actually buys you

A code signing certificate gives Windows a verified publisher name instead of "Unknown publisher", ties your files to one identity for SmartScreen and antivirus engines, and proves the binary was not altered after you built it. For anything that runs in the background, opens network connections or installs a service, an unsigned binary is a non-starter for most business customers.

Where the private key lives

This is the part that changed under a lot of teams. Since mid-2023, publicly trusted code signing certificates have to keep their private key on hardware: a USB token, an HSM, or a cloud signing service. You can no longer download a .pfx file and drop it into a build folder.

That pushes you toward the setup you wanted anyway. The two patterns I like:

What I avoid is a token plugged into one developer's laptop. That turns "who can ship" into "whose laptop is on". It is the same argument as getting Android keystores off laptops in my Unity CI/CD post, and the same reason I treat signing credentials like any other production secret, as covered in handling API keys and secrets on client projects.

Timestamp every signature

Always sign with a trusted timestamp, using an RFC 3161 timestamp server and SHA-256 digests. With signtool that looks like:

signtool sign /fd sha256 /tr <timestamp-server-url> /td sha256 /a MyApp.exe

Without a timestamp, your signature stops validating when the certificate expires, and every copy of your app in the wild starts looking unsigned on the same day. With one, Windows checks the certificate was valid when you signed, and the signature keeps working. Missing timestamps are the most common mistake I see in inherited Windows pipelines.

Sign everything you ship, not just the installer

The installer, the main executable, your own DLLs, any helper process or service binary, and the uninstaller. Antivirus engines look at files individually after install, and an unsigned helper inside a signed installer is exactly the kind of thing that gets flagged on its own.

SmartScreen and antivirus in the first weeks

The honest expectation to set with a client: a brand new certificate on a brand new app will still show warnings for a while.

SmartScreen works on reputation, built from how many people download and run files signed by your certificate without problems. A new publisher starts with none. For years the shortcut was an Extended Validation certificate, which got immediate reputation. Microsoft changed that in 2024, so EV and standard certificates now both build reputation the normal way. EV may still make sense for organisational identity checks, but buy it for the right reason, not to skip the warning.

What actually helps:

Software that touches networking draws extra suspicion, which I knew from working on the Repocket SDK and later on a React Native VPN app with a native tunnel. Behaving like a good guest on the machine, with predictable resource use, clear naming and a clean uninstall, is part of how you stay off blocklists.

Pick the updater before the installer

Most teams pick an installer for how installation looks. I pick it for how updates will work, because updates are what you live with for years.

The realistic options:

The question that decides it is usually: does this app need admin rights? A user-level app should install per user and update silently. Something that runs as a service, as a background networking component often wants to, needs a per-machine install, an elevation prompt and a more careful update path.

Whichever you choose, the update check, a minimum supported version and a remote way to switch features off all ship in version one. You cannot add an updater to a version that does not have one. The kill switch side of that is in feature flags and kill switches for a small team.

What the CI pipeline should do

The Windows pipeline I aim for, in order:

  1. Build on a clean agent, never a developer machine, with pinned SDK and toolchain versions.
  2. Stamp the version into the assembly, the file properties and the installer, from one source in the repo.
  3. Sign every binary, then build the installer, then sign the installer, all with timestamps.
  4. Verify the signatures with signtool verify /pa as a pipeline step, so an unsigned file fails the build instead of reaching a user.
  5. Publish symbols somewhere private so crash reports from the field can be read. Without them, error monitoring on a desktop app is a list of addresses.
  6. Archive every release artifact so you can reinstall any version a user reports a bug against.
  7. Release to a small channel first, internal users or a beta feed, before the update goes to everyone.

The verification step matters: the worst Windows release is a working build that went out unsigned because one step silently skipped.

Test like your users install

Before a release I run the installer on a clean Windows virtual machine, not my development machine, and I download it through a browser so it carries the Mark of the Web. Then:

That last one is underrated: a background process left behind after uninstall is how you lose the trust of the IT person who approved you.

The Microsoft Store is a real option

If your app fits its rules, the Microsoft Store removes a lot of this: Microsoft signs the package, handles distribution and updates, and SmartScreen is not a factor for Store installs. The trade is review, packaging constraints and less control over release timing. For a consumer app with no service or driver, I would seriously consider it. For enterprise tools, SDKs and anything with system-level components, direct distribution with the pipeline above is usually the right call.

The short version

On Windows the binary is the easy part. Get the signing key into hardware or a cloud service and sign from CI, timestamp every signature, sign every file you ship, pick the updater before the installer, ship the update path in version one, and expect SmartScreen reputation to take weeks. Test on a clean machine with a real download. It decides whether your second release ever reaches the people who installed your first. It is also the kind of thing I check early when inheriting a codebase, because it is far cheaper to set up before launch than to fix for users already stuck on version one.


I build cross-platform software across C#, Unity, React Native and the web, along with production AI agents, for startups and teams in the US, UK and Europe. If you are about to ship a Windows app or SDK and want the signing and update pipeline right the first time, read more about my background or book a call.

FAQ

Why does Windows SmartScreen warn about my signed app?

SmartScreen works on reputation, built from how many people download and run files signed by your certificate without problems. A new certificate starts with no reputation, so warnings are normal for the first weeks even when the app is properly signed. Since Microsoft's 2024 change, Extended Validation certificates no longer skip this, so keep the same signing identity across releases and let reputation build.

Do I need to timestamp code signatures on Windows?

Yes. Without a trusted timestamp, the signature stops validating when the certificate expires and every installed copy starts looking unsigned on the same day. Signing with an RFC 3161 timestamp server and SHA-256 digests means Windows checks the certificate was valid at signing time, so the signature keeps working after expiry.

Where should a Windows code signing key be stored?

Publicly trusted code signing keys must now live on hardware: a USB token, an HSM or a cloud signing service. The best setup is a cloud signing service or cloud HSM called from the CI pipeline with a scoped credential, so signing is an audited pipeline step rather than something that depends on one developer's laptop.

Which installer should I use for a Windows app: MSIX, MSI or an update framework?

Choose based on how updates will work. MSIX with App Installer suits modern apps without services or drivers and is what the Microsoft Store wants. An update framework such as Velopack suits per-user apps that should update silently without admin prompts. MSI via WiX or Inno Setup suits apps that need a Windows service, per-machine install or deployment through IT tooling.

Building something in this space?

I take on AI-agent, automation and product work directly — scoped fast, shipped fast.

Book a discovery call →

Keep reading