How to Check a Mac App Before Notarization on macOS 27? 2026 Checklist

For a Mac app distributed directly to users on macOS 27, accept the release only after you verify the Developer ID signature, notarization result, exact delivery artifact, and launch behavior. If the app will ship through the Mac App Store, use the store submission path instead of copying the direct-distribution checklist.

This guide is for independent developers distributing a Mac app directly who need to verify signing, notarization, and delivery files before release.
It also helps small teams shipping a DMG or PKG distinguish container checks from installed-app checks.
If you need a consistent publishing host, it helps you assess whether a remote Mac fits repeated acceptance work.

Last updated November 6, 2026; checked against Apple’s notarization, distribution, workflow, and macOS 27 documentation. Apple’s notarization guide and macOS 27 release notes define the relevant platform and distribution context.

What must the acceptance record prove?

Acceptance is not a single green status. It is a set of linked checks that show what was signed, what was submitted, what users will receive, and whether that delivered app can launch in the intended environment.

Apple’s guidance for direct distribution describes notarization alongside code signing and Hardened Runtime requirements. These are requirements for the direct-distribution route, not a universal checklist for every way to distribute a Mac app. Start with Apple’s macOS notarization requirements and Hardened Runtime documentation.

Separate Apple’s stated requirements from project-level acceptance recommendations:

• Apple’s requirements: follow the signing, Hardened Runtime, and submission conditions that apply to your direct-distribution software.
• Project-level acceptance: retain enough evidence to connect the signed build and notarization response to the exact file users will download.
• Runtime acceptance: launch and exercise the delivered app on a target environment. Notarization approval alone does not establish compatibility or correct behavior.

That separation prevents a common release mistake: treating a notarization result as if it proves the whole release is ready.

Record the identity of the build

Before submitting, record the build identifier used by your team, the signing identity, the artifact type, and the filename or other stable identifier for the release file. Keep the record with the build output. If the artifact changes after submission, the old response does not prove the new artifact was checked.

The Apple code signing services documentation explains the role of signing services. For acceptance, the practical question is whether the signature on the deliverable matches the identity and build your release record says it should.

Keep the submission response and its log

Use notarytool for the submission workflow and save its result and log alongside the release record. Apple documents how to customize the notarization workflow, including the role of submission results. The returned success status is evidence about the submitted item. It is not evidence about a later replacement file, a different package, or an app that was never launched in the target environment.

How does acceptance change by distribution scenario?

The artifact that the user downloads determines what needs to be checked. A signed app inside a container is not the same acceptance target as the container itself.

Direct app download

For an app delivered directly, check the app bundle that users receive. Confirm that the expected Developer ID signature is present, that the notarization submission refers to that build, and that the app launches after download on the target system.

If the app is repackaged, rebuilt, or modified after the notarization submission, repeat the relevant checks against the new deliverable. Do not rely on an earlier app-level result to represent a later release.

DMG delivery

For a DMG release, treat the disk image as part of the deliverable, not merely as a transport wrapper. Apple’s Mac software packaging guidance covers packaging considerations for distribution.

The acceptance record should identify the final DMG submitted for notarization and the exact DMG prepared for users. After processing the ticket as appropriate for that artifact, mount the image and launch the app from the mounted volume. This catches errors that an app-bundle-only check can miss, such as testing one copy while publishing a different image.

A successful result for the app inside a DMG does not, by itself, demonstrate that the final image users download was also accepted and tested.

PKG delivery

A PKG installer needs its own artifact-level record. Check the installer package’s signature and the notarization result associated with the package submitted. Then install it using the intended release path and inspect the installed app’s signature and launch behavior.

Keep the package evidence separate from the installed-app evidence. The package proves which installer was prepared and submitted; the installed app checks prove what the installation produced.

Do not use a DMG acceptance record as a substitute for PKG checks. The artifact and installation path differ, so the evidence must differ too.

Mac App Store release

A Mac App Store submission follows Apple’s store distribution route. It should not be treated as a direct Developer ID download simply because both routes ultimately deliver a Mac app. Apple’s application distribution overview distinguishes distribution paths and their requirements.

For a store release, record the build submitted, the store submission outcome, and the actual release status. Test the released app through the relevant store delivery path. A separate direct-distribution notarization workflow is not a replacement for store submission evidence.

Which decision path fits the release?

Use these conditions before accepting a release:

• If users download a standalone app directly, verify the Developer ID signature, direct-distribution notarization result, exact app build, and launch behavior. Otherwise, identify the actual container and test that.
• If the download is a DMG, check the final DMG and the app launched from its mounted volume. If only the app bundle was submitted or tested, the image is not fully accepted.
• If users install a PKG, retain separate evidence for the signed and notarized package and for the installed app. If the installer changes, repeat the package check.
• If distribution is through the Mac App Store, use the store submission and release record. Do not mark a store build as accepted solely because a separate direct-distribution workflow passed.
• If the release targets macOS 27, record the build host, target architecture, and launch result separately from notarization. Apple’s current platform support information defines the platform’s support boundaries; a notarization result does not prove that an app works on every supported target.

The final branch is important: Apple’s current platform support information and the notarization response answer different questions. The former informs the target environment; the latter reports on the submitted artifact.

A repeatable acceptance workflow

Use an isolated build and acceptance run before applying the same workflow to the production release. This makes it easier to identify which artifact was tested and to preserve a reviewable record.

Build and acceptance evidence

1. Choose the distribution route. Write down whether the release is a direct app, DMG, PKG, or Mac App Store build. Use the matching Apple distribution guidance rather than one checklist for every route.
2. Build in a controlled environment. Record the macOS and Xcode environment used for the build, the target architecture, and the build identifier. Keep environment details with the release record so a later reviewer can tell what was tested.
3. Check signing before submission. Verify that the signature on the actual release candidate matches the intended Developer ID identity and that the direct-distribution configuration meets Apple’s Hardened Runtime and notarization conditions. Do not assume a successful local build means the release artifact is signed correctly.
4. Submit the correct item with notarytool. Submit the artifact that corresponds to the distribution route. Save the service response and submission log. Apple’s notarization workflow documentation is the reference for tailoring this process.
5. Process and validate the relevant ticket. Follow Apple’s workflow for the artifact type and retain the validation evidence. Record whether you validated the app, image, or installer; do not write only “ticket checked.”
6. Test the user’s delivery path. For a DMG, mount the final image and launch its app. For a PKG, install the final package and inspect the installed app. For a standalone app, test the distributed copy rather than a separate development build.
7. Run a target-environment launch check. Verify that the app starts and completes the release-critical actions in the intended macOS environment. Keep this result distinct from the notarization status.
8. Freeze the release artifact. Compare the approved item with the one queued for publication. If the app, package, or disk image changes, rerun the checks affected by that change and update the evidence record.

This workflow produces a reviewable chain: build identity, signing evidence, notarization response, final deliverable, and launch result. Apple’s Xcode archive process documentation can help teams make the archive stage repeatable, but it does not remove the need to inspect the final distribution artifact.

Remote Mac as the publishing host

A remote Mac can perform the same build, signing, submission, and validation steps when it has the required macOS and Xcode environment and controlled access to release credentials. The important acceptance criterion is not whether the Mac is local or remote. It is whether the build and evidence stay tied to the exact artifact being published.

For a repeatable workflow, store the submission response, relevant logs, artifact identifiers, and launch-test result somewhere the team can retrieve after a remote session ends. Limit access to signing credentials and avoid leaving release secrets in shell history or temporary files. These are project security practices, not claims that Apple’s notarization result manages your credentials for you.

If a team is deciding whether to prepare a separate remote host, review the available remote Mac access and support information before moving signing credentials or release work to that environment.

Questions that change the acceptance decision

Does a successful notarization result prove the app can launch?

No. It shows that the submitted item received a successful result from the notarization service. It does not prove that the item tested is the one users will download, that the release works with the target macOS environment, or that the app completes its intended tasks. Keep a separate launch result tied to the final deliverable.

Does replacing a DMG or PKG require another acceptance run?

If a replacement changes the artifact users receive, the earlier artifact-level evidence no longer identifies the new deliverable. Recheck the changed item and update the record. For a PKG, also confirm what the replacement installs. For a DMG, retest the final image and launch the app from that image.

Does macOS 27 compatibility follow from notarization?

No. Notarization and operating-system compatibility are separate acceptance questions. Check Apple’s current macOS 27 platform information, then test the app on an appropriate target environment and record its architecture and launch behavior. Do not infer a project’s support range solely from the notarization response or from the build host.

A release-path comparison before publishing

The qualitative ratings below describe how closely each workflow aligns with the evidence this checklist asks for. They are project-planning assessments, not Apple-issued grades.

The practical rule is simple: choose the row that describes what users actually receive, then retain evidence for that artifact and the app users run.

If the current setup relies on a developer’s personal Mac, it can be difficult to keep a stable publishing environment available; a Windows or Linux machine cannot replace the macOS-specific signing and Xcode steps; and a manually assembled CI host can leave ownership of credentials and release logs unclear. A remote Mac can provide a dedicated macOS environment without buying another physical Mac, but it is not the right fit if the project needs a permanently owned machine, local physical interfaces, or sustained workloads that justify purchasing hardware. For teams that want to assess that trade-off, OrbVPS Mac rental options can be considered after the project’s toolchain, credential policy, and release evidence requirements are defined.

Frequently asked questions