How to Edit a Word Document with Pre-Designed Template Fields

How to Edit a Word Document with Pre-Designed Template Fields Working with Word documents often requires a balance of speed, precision, and consistency. Whether you’re customizing business letters, automating reports, or editing job application templates, modifying pre-designed fields is an efficient method. With the UniOffice SDK, you can now automate and streamline this task using Go.

This guide dives deep into editing Word documents using Go by modifying template fields—perfect for developers and businesses looking to optimize document workflows with UniOffice.

What Are Pre-Designed Template Fields?

Templates in Word documents usually contain placeholders like FIRST NAME, DATE, ADDRESS, and so on. These fields guide the structure and make mass editing faster and less error-prone.

By modifying these predefined fields programmatically, you can produce consistent, customized documents without manually updating each one.

Why Modify Templates with UniOffice?

UniOffice SDK allows developers to edit documents dynamically. This approach is perfect for integrating document generation into applications such as CRMs, HR tools, and legal software.

Key Benefits:

No need to manually edit Word document online
Ensures uniform structure and formatting
Reduces human error
Automates repetitive documentation

Before You Begin: Get Your API Key

To start, create a UniCloud account and obtain your API key. This key is required to authenticate and access UniOffice’s features.

Step 1: Set Up Your Development Environment

If you’re using UniOffice for the first time, begin by setting up your local Go environment.

Clone the Examples Repository

Open your terminal and run:

git clone https://github.com/unidoc/unioffice-examples

Navigate to the Example Folder

Change to the relevant folder for editing documents:

cd unioffice-examples/document/edit-document/

This folder contains the example file and code we’ll modify.

Step 2: Understanding the Code Structure

Let’s break down the provided Go code that allows you to edit documents in Word online using local tools.

1. Import Packages and Load the License

import (
    "fmt"
    "log"
    "os"
    "time"

    "github.com/unidoc/unioffice/v2/common/license"
    "github.com/unidoc/unioffice/v2/document"
)

func init() {
    err := license.SetMeteredKey(os.Getenv(`UNIDOC_LICENSE_API_KEY`))
    if err != nil {
        panic(err)
    }
}

This section loads the required packages and authenticates using your API key.

2. Open the Word File

doc, err := document.Open("document.docx")
if err != nil {
    log.Fatalf("error opening document: %s", err)
}

defer doc.Close()

This opens your template .docx file for editing. The defer statement ensures it will be properly closed after processing.

3. Gather Paragraphs and Structured Tags

paragraphs := []document.Paragraph{}
for _, p := range doc.Paragraphs() {
    paragraphs = append(paragraphs, p)
}

for _, sdt := range doc.StructuredDocumentTags() {
    for _, p := range sdt.Paragraphs() {
        paragraphs = append(paragraphs, p)
    }
}

This part ensures you access both standard and structured paragraphs, which are commonly used in templates.

Structured Document Tags (SDTs) allow grouping of text fields. In templates, SDTs are frequently used for fields like name, title, and date.

Step 3: Modify Template Fields

Now comes the exciting part—modifying template content dynamically.

Here’s a simplified explanation of how the core logic works:

for _, p := range paragraphs {
    for _, r := range p.Runs() {
        switch r.Text() {

            case "FIRST NAME":
                r.ClearContent()
                r.AddText("John ")
                r.AddBreak()

                para := doc.InsertParagraphBefore(p)
                para.AddRun().AddText("Mr.")
                para.SetStyle("Name")

                para = doc.InsertParagraphAfter(p)
                para.AddRun().AddText("III")
                para.SetStyle("Name")

            case "LAST NAME":
                r.ClearContent()
                r.AddText("Smith")

            case "Address | Phone | Email":
                r.ClearContent()
                r.AddText("111 Rustic Rd | 123-456-7890 | [email protected]")

            case "Date":
                r.ClearContent()
                r.AddText(time.Now().Format("Jan 2, 2006"))

            case "Recipient Name":
                r.ClearContent()
                r.AddText("Mrs. Smith")

            case "Title":
                p.RemoveRun(r)

            case "Company":
                r.ClearContent()
                r.AddText("Smith Enterprises")

            case "Address":
                r.ClearContent()
                r.AddText("112 Rustic Rd")

            case "City, ST ZIP Code":
                r.ClearContent()
                r.AddText("San Francisco, CA 94016")

            case "Dear Recipient:":
                r.ClearContent()
                r.AddText("Dear Mrs. Smith:")

            case "Your Name":
                r.ClearContent()
                r.AddText("John Smith")

                run := p.InsertRunBefore(r)
                run.AddText("---Before----")
                run = p.InsertRunAfter(r)
                run.AddText("---After----")

            default:
                fmt.Println("not modifying", r.Text())

        }
    }
}

Each conditional block checks if the text matches a predefined field, clears the old content, and replaces it with the desired value.

This is the heart of how to edit a Word document using code.

Step 4: Save the Edited Document

At the end of the code, you save your modified document with:

doc.SaveToFile("edit-document.docx")

Step 5: Run Your Script

Run the following command in your terminal:

go run main.go

This will generate a new Word document with all the template fields modified.

You now have a fully customized .docx file, generated programmatically.

Real-World Use Cases

HR Automation

Generate customized offer letters by editing template fields like name, designation, salary, and more.

Client Communication

Automate sending tailored proposals and reports by modifying only the relevant fields each time.

Legal Documentation

Create contracts with pre-filled parties, addresses, and terms—all while maintaining format and compliance.

How This Beats Editing Online

Although many tools let you edit Word documents online, they lack the automation and batch-editing capabilities that UniOffice offers.

By using code to edit a document, you ensure:

Repeatability
Accuracy
Integration with larger systems

For high-volume or business-critical editing, this is a game-changer.

Learn More

Explore more UniOffice examples to automate other document types like spreadsheets and presentations.

If you’re wondering more about how to edit a word document with advanced control, UniOffice documentation provides in-depth insights.

Visit Unidoc for more tools and solutions.

Conclusion

By leveraging UniOffice, developers can do more than just edit doc files—they can automate professional-grade document workflows at scale.

This method of editing pre-designed Word templates brings efficiency and consistency to document handling, especially in enterprise environments.

Whether you’re trying to edit a Word document online or programmatically, UniOffice offers scalable, flexible tools to power your automation goals.