KomuraSoft LLC Blog
Windows / C# / COM engineering notes from KomuraSoft LLC.
https://comcomponent.com/en/feed.xml
2026-07-20T00:00:00+00:00
© 2026 KomuraSoft LLC
Jekyll
小村 豪
https://comcomponent.com/en/profile/go-komura/
Power Automate Error Handling and Retry Design — Preventing 'The Flow Was Working, Then It Just Stopped'
https://comcomponent.com/en/blog/power-automate-error-handling-retry-design/
2026-07-18T01:00:00+00:00
2026-07-20T00:00:00+00:00
A collection of design patterns for preventing Power Automate flows from silently stopping without anyone noticing. Based on Microsoft Learn's official specifications, we cover default retry policy values, Try-Catch using scopes, failure notifications, resubmission and idempotency, and concurrency control.
Go Komura
PowerShell Error Handling and Retry Design — From the try/catch Trap to Exit Codes and Retry Best Practices
https://comcomponent.com/en/blog/powershell-error-handling-retry-design/
2026-07-18T00:30:00+00:00
2026-07-20T00:00:00+00:00
A practical rundown of PowerShell error handling: the difference between terminating and non-terminating errors, the -ErrorAction Stop pattern for the try/catch trap, judging success or failure with $LASTEXITCODE, exit code design, and retrying with exponential backoff.
Go Komura
Designing Scheduled Flows in Power Automate — Month-End Processing, Business-Day Checks, and Reminders in Practice
https://comcomponent.com/en/blog/power-automate-scheduled-flow-business-day-design/
2026-07-18T00:30:00+00:00
2026-07-20T00:00:00+00:00
A practical guide to automating recurring processes with Power Automate's Recurrence trigger. Covers the trap of the default time zone being UTC, date expressions, business-day checks driven by a holiday master list, reminder design, and operational cautions such as the 90-day automatic turn-off.
Go Komura
PowerShell Execution Policy and Script Signing — A Practical Guide to Graduating From "Papering Over It With Bypass"
https://comcomponent.com/en/blog/powershell-execution-policy-script-signing/
2026-07-18T00:00:00+00:00
2026-07-20T00:00:00+00:00
PowerShell's execution policy is "a safety feature, not a security boundary." This article covers the differences between policies like RemoteSigned, scope precedence, Mark of the Web and Unblock-File, script signing, and realistic operational patterns for internal distribution.
Go Komura
Automating Data Entry Into Legacy Core Systems With Power Automate for Desktop — Replacing Manual Entry From Excel and Paper With UI Automation
https://comcomponent.com/en/blog/power-automate-desktop-legacy-app-data-entry/
2026-07-18T00:00:00+00:00
2026-07-20T00:00:00+00:00
A practical guide to replacing manual data entry into old core systems that have no API, using UI automation in Power Automate for desktop (PAD). Covers what you can do for free, the licensing needed for unattended runs, and stabilizing flows with selectors and error handling.
Go Komura
Automating Purchase-Order and Invoice PDFs That Arrive by Email With Power Automate — Designing Storage, Routing, Notification, and Extraction
https://comcomponent.com/en/blog/power-automate-email-attachment-automation/
2026-07-17T12:00:00+00:00
2026-07-20T00:00:00+00:00
A practical guide to automating the storage, routing, and notification of purchase-order and invoice PDFs that arrive by email with Power Automate, covering the Outlook trigger and shared-mailbox prerequisites, avoiding false positives from signature images, and reading document contents with AI Builder along with its licensing caveats.
Go Komura
Building an Approval Workflow in Power Automate — Digitizing Paper and Email-Based Approval Requests
https://comcomponent.com/en/blog/power-automate-approval-workflow-guide/
2026-07-17T11:30:00+00:00
2026-07-20T00:00:00+00:00
A practical guide to digitizing paper approval forms and email-attached Excel requests with Power Automate: the types of approval actions, choosing among Forms, SharePoint, and Teams, how to preserve records given the run-history retention limits, and handling rejections and resubmission.
Go Komura
Migrating Excel VBA Macros to Power Automate — What to Replace with Office Scripts, and What to Leave as VBA
https://comcomponent.com/en/blog/excel-vba-to-power-automate-office-scripts/
2026-07-17T11:00:00+00:00
2026-07-20T00:00:00+00:00
A guide to whether Excel VBA macros can migrate to Power Automate, covering what Office Scripts can replace, what only VBA can still do, connector limits, licensing requirements, and a phased migration approach that starts with an inventory.
Go Komura
Information Security 10 Major Threats 2026 — How to Read the Ranking, and What SMEs Should Actually Guard Against
https://comcomponent.com/en/blog/ipa-10-major-threats-2026/
2026-07-17T08:00:00+00:00
2026-07-20T00:00:00+00:00
In IPA's 'Information Security 10 Major Threats 2026,' ransomware attacks took first place for the 11th year running, supply chain attacks came in second, and 'cyber risk around AI use,' selected for the first time, entered at third. This article walks through the organizational top 10 and explains which threats SMEs should treat as their own problem and act on.
Go Komura
Incident Response Doesn't End at Recovery — A Postmortem (Recurrence Prevention) Template for Small Development Teams
https://comcomponent.com/en/blog/postmortem-recurrence-prevention-small-teams/
2026-07-17T07:50:00+00:00
2026-07-20T00:00:00+00:00
Treating an incident as over once it's fixed and apologized for guarantees you'll repeat it. This article translates the blameless postmortem for small teams, covering a template you can write in an hour, a strength decision table for recurrence-prevention measures, and how to triage which incidents get one.
Go Komura
An Introduction to ADRs (Architecture Decision Records) — The Minimal Way to Record 'Why We Designed It This Way' on a Small Team
https://comcomponent.com/en/blog/adr-architecture-decision-record-small-teams/
2026-07-17T07:40:00+00:00
2026-07-20T00:00:00+00:00
Code never explains why it was written that way. We cover how to use an ADR (Architecture Decision Record) — one decision, one Markdown file — to preserve the reasoning behind a design choice, complete with a template, a decision table for what to write up and what not to, and worked examples.
Go Komura
DLL and COM Interface Backward Compatibility — A Decision Table for Which Changes Break Callers
https://comcomponent.com/en/blog/dll-com-interface-backward-compatibility/
2026-07-17T07:30:00+00:00
2026-07-20T00:00:00+00:00
Which changes to a DLL or COM component actually break their callers? We lay out the three layers of compatibility — binary, source, and behavioral — a decision table organized by kind of change, the iron rule that COM interfaces never change, and a practical guide to running semver.
Go Komura
Versioning Your Business App's Database Schema — Migration Practices to Prevent 'Every Customer Has a Different DB'
https://comcomponent.com/en/blog/db-schema-migration-versioning-business-apps/
2026-07-17T07:20:00+00:00
2026-07-20T00:00:00+00:00
A practical guide to versioning the database schema of a business app whose databases are scattered across customer sites. Covers PRAGMA user_version and a C# implementation of forward migrations, a decision table for EF Core Migrations, DbUp, and hand-rolled implementations, and two-stage expand-contract releases.
Go Komura
CI/CD for WinForms / WPF Apps in Practice — Automating from Build to Signing and Distribution with GitHub Actions
https://comcomponent.com/en/blog/winforms-wpf-cicd-github-actions/
2026-07-17T07:10:00+00:00
2026-07-20T00:00:00+00:00
A practical guide to setting up CI/CD for WinForms / WPF apps with GitHub Actions. Covers a minimal YAML for build+test on windows-latest, tag-driven version numbering, wiring up signtool for code signing, and a CI-integration decision table broken down by MSI/MSIX/ClickOnce/xcopy.
Go Komura
Safely Modifying a Legacy Business App That Has No Tests — Characterization Testing and Refactoring in Practice
https://comcomponent.com/en/blog/characterization-test-legacy-refactoring/
2026-07-17T07:00:00+00:00
2026-07-20T00:00:00+00:00
To safely modify a business application with no tests, this article explains, with C# examples, the procedure for a characterization test (the golden master method) that pins down current behavior, how to create seams, and the operational rules for keeping refactoring and feature work separate.
Go Komura
Don't Forget to Decide 'How Many Seconds Is Fast Enough' — Organizing Non-Functional Requirements With IPA's Non-Functional Requirements Grade
https://comcomponent.com/en/blog/ipa-non-functional-requirements-grade/
2026-07-17T06:00:00+00:00
2026-07-20T00:00:00+00:00
Disputes like 'it's too slow' or 'we didn't expect that failure response' usually trace back to non-functional requirements nobody decided on. This article explains, in plain terms for the client side, the six major categories of IPA's Non-Functional Requirements Grade, how to use the grade table and model systems, and a realistic way to apply it.
Go Komura
Should Contracted Development Specs Stay in Excel? — Choosing the Right Format for Deliverables
https://comcomponent.com/en/blog/deliverable-spec-documents-format-excel-word/
2026-07-17T06:00:00+00:00
2026-07-20T00:00:00+00:00
Should the specification and design documents delivered in contracted development stay in Excel 'graph paper' format? This article works through the problems with Excel-based specs from an acceptance-testing and maintenance standpoint, and explains how to choose a format that actually works as a deliverable — including Word and generating documents from a Markdown source.
Go Komura
What Website Clients Should Know Too — Using IPA's 'How to Secure Your Website' as a Checklist
https://comcomponent.com/en/blog/ipa-secure-website-guide/
2026-07-17T04:00:00+00:00
2026-07-20T00:00:00+00:00
What standard should you use to check your company website's security against? This article explains the 11 vulnerabilities and countermeasures covered in IPA's 'How to Secure Your Website,' in language that makes sense to clients and site operators, and shows how to use it when placing an order, at acceptance, and during ongoing operation.
Go Komura
When Your In-House Windows App Gets Flagged as a Virus — Handling Microsoft Defender False Positives and Living With the Performance Impact
https://comcomponent.com/en/blog/windows-defender-false-positive-guide/
2026-07-17T04:00:00+00:00
2026-07-20T00:00:00+00:00
We lay out the proper way to respond when Microsoft Defender flags your in-house Windows app as malware: how modern antivirus detection actually works, how to submit a false-positive report to Microsoft, how to restore a file from quarantine, and how to set up exclusions correctly along with their risks.
Go Komura
Sleep, Hibernation, Modern Standby, and Long-Running Apps — Designing Around 'It Stopped Overnight'
https://comcomponent.com/en/blog/windows-sleep-modern-standby-long-running-apps/
2026-07-17T03:00:00+00:00
2026-07-20T00:00:00+00:00
Why a long-running Windows app can end up 'stopped by the time you check it in the morning,' worked through from the differences between S3 sleep, hibernation, and Modern Standby. Covers how timers and TCP connections behave during sleep, and how to suppress sleep with SetThreadExecutionState.
Go Komura
Where Should SMEs Start on Security? — A Walkthrough of IPA's 'Information Security Guidelines for SMEs,' 4th Edition
https://comcomponent.com/en/blog/ipa-sme-security-guideline-v4/
2026-07-17T02:00:00+00:00
2026-07-20T00:00:00+00:00
Where should small and medium-sized businesses start on security? Drawing on IPA's 'Information Security Guidelines for Small and Medium Enterprises,' 4th edition, this article walks through the Six Articles of Information Security, the 5-minute self-assessment, and SECURITY ACTION step by step.
Go Komura
Do Business Apps Run on Windows on Arm? — The Reality of x64 Emulation (Prism) and Native DLLs/COM
https://comcomponent.com/en/blog/windows-on-arm-business-apps/
2026-07-17T02:00:00+00:00
2026-07-20T00:00:00+00:00
An answer, aimed at developers and IT staff, to 'will our business app run on Windows on Arm?' Covers how x64 emulation (Prism) works, the layers it can't reach (like drivers), the AnyCPU/P-Invoke combination problem in .NET, and an Arm-readiness checklist.
Go Komura
When You Inherit a System With No Source Code and No Documentation — A Practical Playbook for Keeping It Running
https://comcomponent.com/en/blog/no-source-no-docs-system-maintenance/
2026-07-17T01:00:00+00:00
2026-07-20T00:00:00+00:00
A practical playbook for starting operations and maintenance on a business system that has no source code and no specifications. Covers preserving and backing up the running environment, taking inventory of executables and databases, recovering specifications from observed behavior, and deciding between life support, wrapping, and rebuilding.
Go Komura
MAX_PATH and Windows Path/Filename Pitfalls — the 260-Character Limit, Reserved Names, Trailing Dots, and Case Sensitivity
https://comcomponent.com/en/blog/windows-max-path-filename-pitfalls/
2026-07-17T01:00:00+00:00
2026-07-20T00:00:00+00:00
A rundown of the path and filename limits behind the classic 'file not found' bug. Covers the breakdown of MAX_PATH=260, enabling long paths with LongPathsEnabled, reserved names like CON, normalization of trailing dots, and the Path.Combine trap.
Go Komura
How Should You Structure a Contract Development or Operations & Maintenance Contract? — Learning the Quasi-Mandate vs. Contract-for-Work Distinction from IPA's 'Model Contract'
https://comcomponent.com/en/blog/ipa-model-contract-development-maintenance/
2026-07-17T01:00:00+00:00
2026-07-20T00:00:00+00:00
When you outsource system development, how should the contract be structured? Drawing on the 'Information System Model Transaction and Contract' published by IPA, this article explains, in terms accessible to the client side too, the thinking behind multi-stage contracts, the difference between quasi-mandate and contract-for-work agreements, and what an operations and maintenance contract needs to spell out.
Go Komura
Pitfalls of Network Drives and UNC Paths — Working With File Servers (Shared Folders) From a Business Application
https://comcomponent.com/en/blog/network-share-unc-path-pitfalls/
2026-07-17T00:00:00+00:00
2026-07-20T00:00:00+00:00
This article organizes the classic problems that show up when a business application writes to or watches a shared folder: why a drive letter (Z:) is invisible from a service, the permissions each service execution account needs, error 1219, and the caveats around FileSystemWatcher.
Go Komura
What Is a Digital Invoice? How Is It Different From Emailing a PDF Invoice?
https://comcomponent.com/en/blog/what-is-digital-invoice-peppol-jp-pint/
2026-07-16T10:00:00+00:00
2026-07-16T00:00:00+00:00
A digital invoice is a mechanism for exchanging invoice data directly from a seller's system to a buyer's system, without a person in the loop. This article explains, in plain terms, how it differs from PDF invoices, how it relates to Japan's Invoice System, how Peppol and JP PINT work, its relationship to Japan's Electronic Bookkeeping Act, and how small and midsize businesses can realistically get started.
Go Komura
System Tray Icons and Toast Notifications in Windows Apps — NotifyIcon Pitfalls and Choosing the Right AppNotification API
https://comcomponent.com/en/blog/windows-tray-icon-toast-notification-guide/
2026-07-16T09:00:00+00:00
2026-07-16T00:00:00+00:00
A practical guide to keeping a business Windows app resident in the system tray and notifying users with toast notifications. Covers the correct use of NotifyIcon, the design for "close to tray" behavior, re-registration after Explorer restarts, a decision table for the three toast APIs (Windows App SDK AppNotification / Community Toolkit / Windows.UI.Notifications), constraints for unpackaged apps, cases where notifications don't arrive, and architectures for sending notifications from a Win...
Go Komura
Migrating from WordPress to Movable Type — A Practical Guide Worth Documenting Precisely Because It Runs 'the Other Way'
https://comcomponent.com/en/blog/wordpress-to-movabletype-migration-practical-guide/
2026-07-16T08:00:00+00:00
2026-07-16T00:00:00+00:00
A practical, hands-on walkthrough of migrating from WordPress to Movable Type (MovableType.net): when the migration makes sense, importing posts, pages, and images, handling custom post types, carrying over SEO through URL design and 301 redirects, and replacing plugin functionality.
Go Komura
How Long Will VB6 Apps Keep Running? — Runtime Support Status and a Practical Path to .NET Migration
https://comcomponent.com/en/blog/vb6-to-dotnet-migration-practical-guide/
2026-07-16T06:00:00+00:00
2026-07-16T00:00:00+00:00
How long will VB6 applications keep running? This practical guide clarifies the asymmetry between the VB6 runtime support policy (still supported on Windows 11) and the fact that IDE support has already ended, then covers the decision table for full rewrite vs. automated conversion vs. staged migration, the pre-migration inventory, VB6/.NET incompatibilities, and the choice between C# and VB.NET.
Go Komura