Excel checkboxes turn a worksheet from a static grid into an interactive tool. Instead of typing Yes, No, Done, or Pending, I can click a box to mark an item as complete, approved, reviewed, or selected. In current Microsoft 365 versions of Excel, checkboxes are easier to use because I can insert them directly into cells from the Insert tab and evaluate them as TRUE or FALSE. Older workbooks and many enterprise environments still use the legacy Developer tab Form Control checkbox, so I find it useful to understand both methods.

Quick answer: Select a cell and choose Insert > Checkbox. In older versions of Excel, I enable the Developer tab and insert a Form Control checkbox.

What are checkboxes in Excel?

In Excel, I use checkboxes because they can feed worksheet logic. A checked box represents TRUE, while an unchecked box represents FALSE. I can then use those TRUE/FALSE values in formulas, filtered lists, dashboards, conditional formatting rules, and progress summaries.

I usually reach for checkboxes when I want a spreadsheet to behave like a lightweight application. For example, a team can use them to track completed tasks, a manager can use them to review onboarding steps, and an operations team can use them to confirm that inventory or compliance checks have been performed.

How to insert a checkbox in Excel using Microsoft 365

The simplest way to add checkboxes is the modern Microsoft 365 method. Microsoft documents the newer workflow as selecting the target range and choosing Insert > Checkbox. A checked checkbox stores TRUE, and an unchecked checkbox stores FALSE, which means I can reference the checkbox value directly in formulas.

1. Select the cell or range where the checkboxes should appear.
2. Go to the Insert tab on the ribbon.
3. Select Checkbox.
4. Click a checkbox to toggle it on or off.

I use this approach for new task lists, trackers, review logs, and interactive reports because the checkbox lives in the cell and behaves more like worksheet data than a floating object.

How to add checkboxes using the Developer tab

The legacy method uses a Form Control checkbox from the Developer tab. I still see this method in organizations that maintain older Excel workbooks, use perpetual Office versions, or need compatibility with existing spreadsheet templates. Microsoft notes that Form Controls are inserted from the Developer tab and that checkboxes work well for forms with multiple options.

1. If the Developer tab is not visible, go to File > Options > Customize Ribbon.
2. Under the main tabs list, check Developer, and then select OK.
3. Open the Developer tab.
4. Select Insert and then choose the Check Box option under Form Controls.
5. Click the worksheet where the checkbox should appear.
6. Right-click the checkbox to edit or remove the default label.

Developer tab checkbox workflow at a glance

1 Open Options

2 Enable Developer

3 Open Developer tab

4 Choose Form Control

5 Click worksheet

6 Edit label

I still find legacy Form Control checkboxes useful, but they behave differently from modern checkboxes. They sit on top of the worksheet as controls, so positioning, copying, sizing, and cell linking require more care.

How to link checkboxes to cells

Modern Microsoft 365 checkboxes do not require me to set up a separate linked cell because the selected cell itself evaluates as TRUE or FALSE. With legacy Form Control checkboxes, I usually link each checkbox to a worksheet cell so formulas can read its state.

1. Right-click the Form Control checkbox.
2. Select Format Control.
3. Open the Control tab.
4. In Cell link, select or type the cell that should store the checkbox result.
5. Select OK.

When the checkbox is checked, the linked cell returns TRUE. When the checkbox is unchecked, the linked cell returns FALSE. That linked value is what makes checkboxes useful when I build formulas, summaries, and dashboards.

Practical uses for checkboxes in Excel

There are many productive daily use cases for checkboxes in Excel. I’ll list some popular ideas for you here.

Create a task tracker

I add task names in one column and checkboxes in the next column. As work gets completed, I can check each box. A summary cell can count completed items and show progress without requiring manual status updates.

Build a project checklist

For project work, I use checkboxes to track deliverables, approvals, testing steps, launch readiness, or documentation reviews. This works especially well when I share the checklist during status calls or use it as a lightweight project control sheet.

Track employee onboarding

I find checkboxes especially practical for onboarding because each row can represent a required step, such as account creation, equipment assignment, training completion, policy acknowledgment, or access review.

Manage inventory reviews

Operations and IT teams can use checkboxes to mark whether equipment, software licenses, stock items, or configuration records have been reviewed. When I pair them with filters, it becomes easy to see what still needs attention.

How to use formulas with checkboxes

Because checkbox values resolve to TRUE or FALSE, I can use formulas to summarize checked items, calculate progress, or drive conditional messages. For example, if checkboxes are in cells B2:B20, I use the following formula to count completed items:

=COUNTIF(B2:B20,TRUE)

To calculate a completion percentage, divide completed items by the total number of checklist items:

=COUNTIF(B2:B20,TRUE)/COUNTA(A2:A20)

I format the result as a percentage to show checklist progress. I can also use an IF formula to display a status message:

=IF(B2,"Complete","Not complete")

These formulas make checkboxes useful for dashboards, task lists, project trackers, and audit logs because the worksheet updates as people interact with it.

Common checkbox problems and fixes

Nothing works 100% of the time, right? Here is a list of the most common issues you’ll run into when working with checkboxes in Excel and how to fix them.

The Developer tab is missing

If I need legacy Form Control checkboxes and do not see the Developer tab, I enable it from File > Options > Customize Ribbon. Then I check Developer under the main tabs list.

The checkbox will not move or align properly

This usually happens with legacy Form Control checkboxes because they are worksheet objects rather than in-cell values. For new files, I use modern Microsoft 365 checkboxes when available. For legacy controls, I copy and paste carefully, align the control with the target cell, and confirm the linked cell is correct.

Copying multiple checkboxes is difficult

Modern checkboxes are easier for me to copy because they live in cells. I select a range, insert checkboxes once, or copy the cells that already contain them. With legacy Form Controls, copied checkboxes may need separate cell links, so I verify that each control writes to the correct row.

Checkboxes behave differently in older files

Compatibility depends on the Excel version and checkbox type. I use Microsoft 365 checkboxes for current workbooks, while legacy Form Controls may be required for older desktop environments or existing templates. Microsoft notes that legacy checkbox controls are tied to the Developer-tab Form Controls workflow and are not the same as the newer checkbox feature.

Excel checkboxes are useful, but they’re not always the best choice

Excel works best when the checklist is part of a workbook that people are already using for calculations, reporting, or analysis. If you’re tracking a small number of tasks alongside budgets, inventory data, project metrics, or operational reports, checkboxes let you add lightweight workflow without introducing another platform.

But I wouldn’t build a team-wide task management process around Excel if Microsoft Lists, Planner, or another purpose-built tool is available. Excel doesn’t provide assignment tracking, notifications, history, or reminders. As soon as multiple people need to collaborate on the same checklist over time, maintaining the spreadsheet often becomes more work than managing the tasks themselves.

Use Excel	Use Microsoft Lists	Use Planner
The checklist lives alongside spreadsheet data	The process needs structured tracking and reporting	The work involves tasks, owners, and deadlines
One person or a small team maintains it	Multiple people update the same records	Tasks need assignment and progress tracking
You need formulas and calculations	You need views, filters, and workflow automation	You need project-style task management
The checklist is temporary or ad hoc	The process will exist long term	The work requires accountability

Frequently asked questions

The post How to Add and Use Checkboxes in Excel appeared first on Petri IT Knowledgebase.

Since launching the Syncfusion^® Toolkit for .NET MAUI, we’ve continued expanding the collection with new controls driven by common developer needs. Today, we’re excited to introduce the fifth set of open-source controls for .NET MAUI, adding Grid Splitter and Interactive Viewer to the Toolkit.

This release also includes quality improvements, performance enhancements, and bug fixes across existing controls.

Grid Splitter

Many desktop-style applications need resizable layouts that let users adjust the space allocated to different content areas. Whether you’re building a file explorer, dashboard, editor, or management application, users often expect to resize panels based on their workflow.

The new .NET MAUI Grid Splitter makes this easy by allowing users to resize, expand, and collapse adjacent layout regions using touch, mouse, or pointer interactions.

Key features

• Resize neighboring panes with simple drag interactions.
• Expand or collapse panels using built-in controls.
• Support both horizontal and vertical layouts.
• Set minimum and maximum pane sizes to maintain consistent layouts.
• Add, remove, collapse, or expand panes programmatically at runtime.
• Customize separator size, color, icons, and templates to match your application’s design.

The following image shows the Grid Splitter in action.

Interactive Viewer

Displaying large images, diagrams, maps, or technical drawings often requires more than a standard image control can provide. Users need a smooth way to zoom in, move around, and inspect details without sacrificing usability.

The new .NET MAUI Interactive Viewer provides built-in zooming, panning, and rotation capabilities, making it easier to create rich viewing experiences across both desktop and mobile platforms.

Key features

• Smooth zooming and panning for exploring visual content.
• Rotate content to view it from different angles.
• Quickly return to the original view with a reset option.
• Control the viewing experience with configurable minimum and maximum zoom levels.

The following image demonstrates the Interactive Viewer.

Performance and quality updates

Alongside these new controls, we’ve continued improving the overall Toolkit experience with performance optimizations, stability enhancements, and bug fixes across existing controls.

These updates help ensure a more reliable and consistent experience when building .NET MAUI applications with the Syncfusion Toolkit.

Supercharge your cross-platform apps with Syncfusion's robust .NET MAUI controls.

Try It Free

Conclusion

With the addition of Grid Splitter and Interactive Viewer, the Syncfusion Toolkit for .NET MAUI continues to expand its collection of open-source controls for modern application development.

Whether you’re creating resizable workspaces, dashboard-style layouts, image inspection tools, map-based applications, or technical viewers, these controls can help you deliver richer user experiences while reducing the amount of custom code you need to maintain.

Both controls are available through the Syncfusion .NET MAUI Toolkit on NuGet and GitHub, along with documentation and sample projects to help you get started quickly.

If you’re looking for a broader set of enterprise-grade UI components, be sure to explore Essential Studio for .NET MAUI, which includes advanced controls such as DataGrid, ListView, Scheduler, Charts, and more.

We’d love to hear your feedback as we continue to enhance the Toolkit and expand its open-source offerings. If you have any questions, feedback, or need assistance, reach out through our support portal, support forum, or feedback portal where our team will be happy to help.

Happy coding!

This past week has been monumental in the realm of artificial intelligence, reflecting the bubbling tech advancements that have been taking shape over the last six months. Significant launches, such as Fable 5.1 and Mythos from Anthropic, alongside GPT-6 Astra, signify a rapid progression towards artificial general intelligence (AGI) and perhaps even artificial superintelligence (ASI). While these innovations have garnered extensive attention, NVIDIA has unveiled something that is bound to reshape the AI landscape: the NVIDIA PAIR.

NVIDIA PAIR, or Personal AI Router, represents a bold leap into the world of local AI. The concept aligns seamlessly with NVIDIA’s broader strategy to democratize AI technologies and embrace the ethos of open AI models, open weights, and open datasets. This blog will explore how NVIDIA’s PAIR could be a game-changer, particularly emphasizing their acquisition of Hugging Face and the implications of this move.

Based on content from Sam Witteveen

The Significance of Open Weights and Hugging Face Acquisition

NVIDIA has established itself as a leader in AI by not only releasing open-weight models but also by accompanying them with comprehensive training recipes and datasets. This strategic approach has made NVIDIA the top contributor of repositories on Hugging Face, overtaking other enterprise players. Their recent acquisition of Hugging Face, valued at just under $13 billion, marks a significant investment in open-weight models, further solidifying NVIDIA’s commitment to open AI.

Contrary to concerns about this acquisition harming the open community, many view it as a protective move, preventing other companies from making restrictive changes that could stifle innovation. Hugging Face has become a hub of local AI, an ecosystem that NVIDIA is eager to integrate with its own technologies, thereby harnessing the full potential of AI hitting mass adoption.

NVIDIA PAIR: The Future of Local AI Networking

The introduction of NVIDIA PAIR marks an innovative step towards seamlessly integrating multiple AI-capable devices within a single network. As households and workplaces increasingly deploy AI-driven technologies, NVIDIA anticipates an environment where devices with GPUs or accelerators work in tandem for optimal performance. PAIR aims to act as a personal inference traffic director within your local network, managing the distribution of AI tasks across various devices without any additional modification required from the user’s perspective.

Unlike SwitchYard, which manages model selection across different API-hosted environments, PAIR focuses on hardware you directly control. It supports agentic software capable of delegating tasks amongst parallel sub-agents, maximizing resource utilization without the typical bottleneck of queued requests waiting for a single GPU.

Open Source Vision and Community Involvement

Underscoring its commitment to open-source initiatives, NVIDIA has released PAIR under the Apache 2 license, inviting the community to contribute, fork, and modify. This proactive move ensures adaptability, community-driven enhancements, and extended support beyond NVIDIA’s original architecture. Current supported environments include Windows, Linux, and macOS, and future expansions seem inevitable as pull requests start rolling in from innovative developers around the globe.

PAIR does not amalgamate your hardware into a Mega-GPU, but it offers the tantalizing capacity of handling more parallel requests—a feature which underlines its essence as a key player in local AI development. This forward-thinking approach invites us to ponder whether future integrations might see PAIR coalesce with other technologies like SwitchYard.

Early Days: Setting the Pace for AI’s Local Future

Despite its fresh release, PAIR is adaptable for various applications and provides a glimpse into the eventual direction local AI could take, potentially integrating more sophisticated functionalities or even encompassing cloud networks. Whether in deploying LLMs or managing everyday tasks, NVIDIA’s latest pioneering product lays down a strong foundation for innovations yet to come.

As NVIDIA forges pathways into the future with PAIR, one can only imagine where the realm of local and personal AI networking will take us. Amidst an era where AI technologies are increasingly becoming omnipresent in personal and professional domains, NVIDIA is at the forefront, ready to navigate the intricate waters of innovation and community collaboration.

Like me, Sumeet Gayathri Moghe is tired of poor presentations with bad slide decks. He's started to write a series of posts on how to avoid these calamities, beginning with a post that questions whether a presentation is needed at all.

more…

AI agents make telemetry costs harder to predict. This post compares the three pillars against the wide event model, and explains why wide events keep AI observability costs predictable without sacrificing the context engineers need.

Access control belongs on the same day-zero checklist as networking and storage.

On most on-prem clusters, it never makes the list.

The Identity Gap

Managed cloud Kubernetes ships IAM or SSO integration out of the box. Self-hosted clusters don’t. Access defaults to a static client certificate or a long-lived token, issued once and rarely revisited. That certificate keeps working long after the person it was issued to has left, changed roles, or lost the device it lives on. Nothing in the cluster’s authentication path checks whether they should still have access. Revoking it means finding every copy of a file, and in practice, that doesn’t happen completely. The moment more than one or two people need different levels of access, managing that per person, per file, becomes its own ongoing job.

Put an identity provider (Keycloak or any OIDC-compliant provider) in front of the cluster instead. Access should follow an account and its group membership, not a certificate file. Configure it with a public OIDC client using PKCE, not a confidential client with a secret. Access changes become identity operations: add someone to a group, remove someone from a group. No file distribution required.

Architecture: three moving parts

The integration has three components that need to agree with each other:

• kubectl, with the kubelogin exec plugin. Starts the login, gets a token from the identity provider, and attaches it to every API request.
• The identity provider (Keycloak). Authenticates the user and issues an ID token carrying their username and group membership.
• kube-apiserver, configured with --oidc-issuer-url, --oidc-client-id, and --oidc-groups-claim. Validates the token, extracts username and groups, and lets RBAC decide what that identity can do.

_{kubectl authenticates against the identity provider, then presents the resulting token to kube-apiserver, which validates it and hands it off to RBAC.}

kubectl never talks to the API server first. A kubectl exec-credential plugin (kubelogin, also distributed as “kubectl oidc-login”) intercepts the request, drives the browser-based login against the IdP, and hands the resulting ID token back to kubectl as a bearer credential. The API server validates that token directly against the IdP’s public signing keys. It never needs network access to the IdP itself beyond fetching those keys once.

The client configuration decision that matters

Configure this client as public, not confidential. A confidential client issues a client secret, which then gets pasted into the kubelogin plugin config, and ships to every machine that needs cluster access.

A secret that has to be distributed to every client that uses it isn’t functioning as a secret. It’s a shared static credential with extra steps, and rotating it means a coordinated config push to every machine rather than disabling one compromised identity.

OAuth 2.1 already settles this for native and command-line applications. Make the client public. Issue no secret at all. Use PKCE (Proof Key for Code Exchange) instead, which stops anyone who intercepts the authorization code from redeeming it. PKCE works by having the client generate a random value locally, send a hash of it with the initial login request, then prove possession of the original value when exchanging the code for a token. An interceptor holding only the code can’t complete that proof.

The client, in Keycloak’s admin console, ends up configured as:

• Client ID: kubernetes
• Client authentication: Off (public client, no secret issued)
• Standard flow: On
• Direct access grants: Off
• Require PKCE: On, method S256
• Valid redirect URIs: http://127.0.0.1:* and http://localhost:* (loopback only, nothing external)
• Web origins: http://127.0.0.1:* and http://localhost:*
• Client scopes: openid, profile, email, groups

_{General settings: the Kubernetes client, registered as OpenID Connect}

_{Access settings: redirect URIs and web origins locked to loopback only}

_{Capability config: Client authentication Off, Standard flow, Require PKCE On (S256)}

Deployment walkthrough

1. Add the groups claim mapper

Kubernetes has no concept of “users” as a first-class object. RBAC binds to usernames and groups asserted by the token, so the IdP needs to actually put group membership into the ID token. “In Keycloak”is a protocol mapper on the client scope, of type Group Membership, mapped to the claim name groups.

_{Group Membership mapper on the realm-level ‘groups’ client scope: Token Claim Name ‘groups’, Add to ID token On}

2. Point kube-apiserver at the issuer

--oidc-issuer-url=https://<your-keycloak-host>/realms/<realm>
 --oidc-client-id=kubernetes
 --oidc-username-claim=preferred_username
 --oidc-groups-claim=groups

If Keycloak’s certificate isn’t signed by a publicly trusted CA (the common case for a self-hosted) on-prem identity provider, add one more flag pointing at that CA’s certificate:

--oidc-ca-file=/etc/kubernetes/pki/oidc-ca.crt

The API server needs to trust this connection to fetch the issuer’s signing keys. Without it, OIDC authentication fails with a TLS verification error that has nothing to do with the login flow itself, which makes it a confusing one to debug the first time you hit it.

3. Configure the kubectl side

kubeconfig gets an exec-credential entry instead of embedded certs or a static token:

users:
 - name: oidc
   user:
 	exec:
   	apiVersion: client.authentication.k8s.io/v1
   	command: kubectl
   	args:
     	- oidc-login
     	- get-token
     	- --oidc-issuer-url=https://<your-keycloak-host>/realms/<realm>
     	- --oidc-client-id=kubernetes

No secret field. There’s nothing to put there.

4. Bind groups to RBAC

apiVersion: rbac.authorization.k8s.io/v1
 kind: ClusterRoleBinding
 metadata:
   name: platform-viewers
 subjects:
   - kind: Group
 	name: platform-viewer
 	apiGroup: rbac.authorization.k8s.io
 roleRef:
   kind: ClusterRole
   name: view
   apiGroup: rbac.authorization.k8s.io

Access changes now happen entirely in the IdP. Add someone to the platform-viewer group, and the next token they mint carries that group. The binding above applies immediately. No cluster-side change. No new kubeconfig to distribute.

Try it out

Using kubelogin as the exec plugin, a first login looks like this from the terminal:

$ kubectl get pods
 Opening in existing browser session.
 NAME                    	READY   STATUS    RESTARTS   AGE
 web-7f9c9c4d8-2xk9p     	1/1 	Running   0      	3d

The first call opens a browser window against the IdP; every call after that reuses the cached token until it expires, at which point kubelogin silently uses the refresh token to get a new one without another browser round-trip.

To confirm what identity and groups actually landed in the token:

$ kubectl auth whoami
ATTRIBUTE   VALUE
 Username	jane.doe@example.com
 Groups  	[platform-viewer system:authenticated]

The bottom line

None of this requires reworking how the cluster runs. It is a public OIDC client, one group membership mapper, a handful of RBAC bindings, and a kubectl plugin many engineers already have installed for other clusters. The setup cost is a single afternoon, not a platform migration.

What changes is what the cluster gets in return. Access follows group membership in the identity provider instead of a certificate file, so granting or revoking a level of access becomes a group change, not a search for every copy of a file across every laptop. There is a deeper benefit too. Kubernetes can log every request that hits its API server, but that audit trail is only as useful as the identity attached to each entry. A shared kubeconfig authenticating everyone as the same generic identity, often literally ‘cluster-admin’ means every audit log entry says the same thing no matter who actually ran the command. Federate identity through an OIDC provider instead, and every request the API server logs carries the person who actually made it. The audit trail stops being a list of anonymous actions and becomes an actual record of who did what, and it costs far less to set up than most teams assume.