Keeping notes honest and reliable in your Power Apps can be a struggle, especially when users accidentally or intentionally overwrite or delete important comments. Whether you’re managing approvals, ticketing, compliance, or any process where accountability matters, maintaining a transparent history of notes is crucial. This post explains how to use a simple Power Apps technique that appends notes instead of rewriting them. It also shows how to automatically log who added each note and when it was added, creating a clean, tamper-proof audit trail.

Why Honest, Immutable Notes Matter in Power Apps

Many apps rely on notes to track decisions, updates, or progress. Unfortunately, users may overwrite previous notes or erase them, either by mistake or on purpose. This can lead to confusion, miscommunication, and a loss of critical history. For example:

• In approval workflows, changing notes can obscure why a decision was made.
• In ticketing systems, notes hold the record of issue handling. Altering them hides past actions.
• In compliance tracking, audit trails must remain intact to meet regulations and ensure transparency.

Having a notes system that only lets you append new information, without deleting or changing old entries, secures data integrity. This method helps keep everyone accountable while making past notes visible at all times.

The trick is to use Power Apps’ Patch function to add new notes on top of existing ones. Each update records:

• Who added the note (username)
• When the note was added (timestamp)
• The new comment entered

All previous notes stay untouched and clearly visible.

Benefits of Appending Notes This Way

• Auto-logs the user’s name for every note entry
• Timestamps each note for accurate history tracking
• Prevents overwriting or deletion of prior notes
• Supports rich text formatting for better readability
• Keeps a clean audit trail ideal for approvals, ticketing, compliance, and accountability

This approach takes your Power Apps notes beyond simple text fields and transforms them into a robust record keeping tool.

---

Setting Up Your Power Apps Notes Section: UI and Structure

Creating a user-friendly and functional notes area starts with good layout and controls. Here’s how to build it step by step.

Organizing with Containers and Visibility

First, place your notes components inside containers to keep things tidy and easy to manage.

• Use a vertical container so your notes and buttons stack automatically with consistent spacing (usually a gap of 20 pixels). This saves you from manually setting coordinates.
• Make sure to name containers clearly, like containerNotes, so coworkers understand their purpose without confusion.
• Set containers to appear only when needed, such as when the Notes tab is selected. Use visibility properties with conditions like TabSelected = "Notes".

Adding Key UI Components Inside the Container

Inside your main note container, include the following elements:

• A modern button for saving notes. Position it on the right, add some padding (about 10 pixels), and make it wide enough (around 150 pixels) to show a label and icon.
• Labels for “Add Notes” and “Previous Notes” at the top of each section, styled with bold font weight for clarity.
• A rich text editor input area for users to type their new notes. Set the height to about 200 pixels or more for comfortable typing space. Clear the default text so it starts blank.
• An HTML text control below to display all previous notes with rich formatting. Turn on flexible height so it expands according to content.

Designing for User-Friendliness

Using modern buttons instead of basic clickable areas improves the user experience. Transparent buttons layered over gallery items simulate clickable zones while keeping nearby controls reachable.

This clean design approach ensures users can easily read previous notes, add new comments, and understand when the save button is enabled or disabled.

---

Ensuring Notes Append Instead of Overwriting: The Patch Method

The heart of this system is the Patch function, which updates your SharePoint list by appending new note content rather than overwriting the entire notes field.

What Patch Does in This Case

Patch connects your app with your data source—in this case, a SharePoint list called software testing checklist. Instead of replacing the existing “notes” field, patching appends new information, preserving earlier entries.

Breakdown of the Patch Statement

Here’s what the Patch formula does in order:

• Identifies the current item being edited with a variable (e.g., varThisItem).
• Updates the notes field by taking what’s already there (varThisItem.Notes).
• Adds the current date/time using the Now() function.
• Wraps the timestamp and username in bold tags (<strong>) to highlight who made the note and when.
• Inserts a line break (<br/>) for separation.
• Adds the new comments from the rich text editor.

The Patch statement looks like this in essence:

Patch(
  'software testing checklist',
  varThisItem,
  {
    Notes: varThisItem.Notes &
      "<br/>" &
      "<strong>" & Text(Now(), "yyyy-mm-dd hh:mm") & " - " & User().FullName & "</strong><br/>" &
      RichTextEditor1.HtmlText
  }
)

Resetting and Feedback

After saving:

• The rich text editor input is reset to blank, ready for new notes.
• If the Patch succeeds, a notification confirms the notes were saved.
• If there’s an error, an error message appears.
• The app navigates back to the gallery or main view and clears any form state variables.

Controlling the Save Button’s Enablement

Make sure users can’t save empty notes by disabling the save button when the rich text editor is blank.

The button’s DisplayMode property uses this formula:

If(IsBlank(RichTextEditor1.HtmlText), DisplayMode.Disabled, DisplayMode.Edit)

This way, the button lights up only when there’s content to save.

Summary of the Patch Process

• Read existing notes from the selected record.
• Append timestamp, username, and new note using HTML formatting.
• Update the SharePoint list with the combined notes.
• Reset input and notify user upon success or failure.
• Enable the save button only when new text exists.

---

Real Use Cases and How the Notes Feature Works Live

This append-notes system fits perfectly in apps like the software testing application example where accountability is key.

Tracking Testers and Restarts

In the app, testers are assigned, and users can track when testing starts or restarts. Notes get updated with comments and actions:

• When a restart occurs, a pop-up asks for confirmation and optional comments to avoid accidental clicks.
• The system logs who restarted testing, when, and with what remarks.
• All notes, including restarts and previous log entries, are visible in a clean, chronological feed.

User Interaction and Viewing Notes

Users click a button to open a detailed record. The notes section shows:

• A blank box for new notes.
• A displayed list of previous notes in rich text.
• The save button activates only after typing new comments.
• Upon saving, the notes update by appending, never replacing, old entries.

SharePoint Backend Integration

All notes are stored in SharePoint, keeping a reliable central record. The HTML text control fetches notes from SharePoint and renders formatted text with line breaks and bold entries.

Why This Matters

• The audit trail is transparent with no hidden changes.
• It helps teams stay accountable.
• Perfect for workflows where tracing history is important: approvals, incident handling, compliance audits, and ticket tracking.

Use Cases Checklist

• Compliance and audit logs
• IT ticketing systems
• Workflow approvals
• Testing and QA tracking
• Customer support notes

---

Coming Up Next: Creating PDFs and SharePoint Storage

This notes approach is just the start. A follow-up tutorial shows how to:

• Automatically convert these appended notes into PDF documents.
• Save the PDFs into a SharePoint document library for safer, long-term archiving.
• Use Power Automate flows to handle PDF creation and storage.

The app will even have a PDF tab with a gallery view and previews, linking directly to the SharePoint files.

This extra step adds another layer of auditing power and backup that’s useful for compliance-heavy environments.

---

Helpful Resources and Next Steps

For those eager to go further, here are some supporting resources:

• Watch the Modern PowerApps Popups for User Confirmation tutorial to learn about popup confirmations used for restarts.
• Download the sample Power App, SharePoint schema, and Power Automate flow templates by joining the community on Ko-fi.
• Connect with Stephanie Marshall on LinkedIn for updates and professional insights.
• Support her work with a coffee donation to encourage more tutorials.

Don’t forget to like, comment, and share your questions. Your feedback helps create videos and posts tailored to your needs.

Quick Start Checklist

• Create a vertical container for notes with clear visibility rules.
• Add a rich text editor for new notes plus an HTML text control for previous notes.
• Use the Patch formula to append notes with username and timestamp in bold.
• Control the save button’s enabled state based on text input.
• Test saving notes and review the audit trail displayed.
• Subscribe to stay updated on PDF generation and advanced audit features.

Have these basics in place, and you’ll never lose important notes again in your Power Apps.

---

Keep your notes honest and your app accountable. See you in the next part of the series!