On this page you can find some of my setups I have used or am still using to implement GTD on the Newton. Here are some quick links to the software discussed below:

Initial Thoughts

GTD probably does not need much further explanation, but there are a couple of characteristics which make using the Newton interesting for GTD:

  • GTD makes heavy uses of lists, e.g. the next action and project lists
  • Items on the next action list are categorized by context
  • Items on the next action list are also connected to items on the projects list
  • GTD uses the concept of a "hard landscape" for items that need to be done on a specific day (meetings, to do items)
  • The projects and next action lists need to be reviewed frequently

All of these things can be done on the Newton in many different ways which are described below. I present them in the order I have used them to highlight how I got closer to the essence of a GTD workflow.

To Do Based Setup

I have been using the excellent DateMan from Standalone Software for a long time, so the first setup was a more structure approach to using DateMan:

  • Folders in DateMan represent different projects
  • DateMan's agenda view is the main view to see all relevant information in one place
  • More Folders can be used to overcome the limit of available folders per Newton application to handle a larger number of projects
  • DateMan Notes allows bringing in notes from the built-in Notes application to the agenda view. These notes contain the project notes.
  • The "hard landscape" is managed via regular appointment and event entries, as well as by assigning the highest priority for to do items which have to be done on a specific day

My workflow in this setup would be to create as many to do items per project as known, and assign priorities to them so that they would step by step lead to project completion. Project notes would be added to the corresponding note in the Notes application.

In the agenda view, I would then see all to do items for all projects, with the most important ones listed first. I could further filter by projects to just see the project relevant items.

The main problem with this setup is the potentially large number of to do items:

  • It is hard to focus when too many items are listed, even though the most important items would represent the immediate next action, other items are visible as well and cause distraction
  • It is often not possible to find proper priorities for all to do items, and quite a lot of time is spent to reassign priorities. This is even more difficult when looking at all items from all projects
  • Using folders as projects creates a mental barrier for creating a new project, a project is made something bigger than it actually would be in GTD terms


Based on my experiences with the to do based setup, I created Flashpoint to make creation of projects a more natural task, and to automate the priority assigment. Flashpoint allows structuring of projects into subprojects, and using priorities per project which are relative to the parent project. This simplifies finding absolute priotities for next actions, their relationship to each other is calculated automatically.

Fundamentally, my main idea behind Flashpoint was to help figuring out which of the next actions to do next. In addition to that, it helps in structuring projects further.

After using Flashpoint for a while I noticed some flaws with my underlying assumptions:

  • The project structure is too rigid, most of the projects I'm working on change their shape over time, and lots of projects come and go. This is probably one of the more important points in GTD: Projects can be anything which takes more than one task to complete, and you can have many of them. Managing projects must therefore be very easy, not only from a technical perspective (i.e. having a tool which can rearrange projects), but also from a mental perspective. Even if it is possible to rearrange projects very easily, there is still time needed to think about the project structure
  • The problem which next action to chose is not easily solved via priorities alone. Priorities can help, but they have to be correct in the first place. I found that priorities are actually counterproductive, a task will not be done simply because it is important, and if high importance is indicated, but the task is not doable, you will get frustrated. Tasks have to be doable, that is the first goal.

Flashpoint turned out to be more of a project management tool than a GTD tool.

List Based Setup

The main conclusions from using Flashpoint were:

  • Projects change too frequently to try to structure them, a list of projects is the most effective way of organizing work.
  • Next actions have to be doable right away without the need to think about them beforehand.
  • Priorities do not help in steering the work.

Putting these conclusions into action resulted in a very simple list base setup. I dropped the idea of priorities and project structures completely and used only the built-in applications. I would recommend this setup as a starting point for people trying GTD since it is lightweight and does not require additional software. The basic structure consists of just a few notes:

  • All projects are held in one checklist called "Projects" in the Notes application
  • Next actions are stored in one outline called "Next Actions"
  • Waiting for items are held in a checklist as well
  • Someday/later items are stored in a separate folder in Notes, either as separate notes, or together in one or more outlines

The project checklist can be structured further if needed, e.g. each project can have comments or possible actions under it, but this is not necessary. The checkboxes in the project checklist are used to indicate whether the project has a next action. During the project review, the boxes are checked, and when completing next actions, the boxes are unchecked.

The next action outline should be structured using contexts, e.g. @work or @home.

Overall this lightweight setup was quite usable. It highlighted the earlier conclusion that work is very dynamic, and it is not useful to plan too far ahead. As an example, next actions were moved back to the associated project quite frequently, either because they were not refined enough, or because they would not move the project forward because other circumstances had changed.

The main problem with this setup is however the difficulty to do a project review. There is no information linking a project to a next action, unless some sort of project identifier is added to the action. Another problem is that keeping the project related information on the project checklist is not very flexible, especially due to the way the Newton checklist stationery works: A topic becomes unchecked if subtopics are unchecked, which interferes with the usage of the checkbox to indicate next actions.

Extended To Do Setup

Since I have been a happy DateMan user for a while, and really like the agenda view, I tried to improve the simple list based setup further by incorporating DateMan into the setup. I still deal with "hard landscape" items quite regularily, or want to write down an action without too much overhead. For that, the agenda view in DateMan works very well for me. Adding priorties is sometimes useful too. The lack of being able to connect actions and projects was another issue I wanted to tackle. And last but not least, storing project related information in a more free form way should be possible as well.

The extented to do setup has this structure:

  • Projects are individual outlines in Notes, stored in a "Projects" folder
  • Next actions are to do items in DateMan, stored in context folders (e.g. @work or @home)
  • Waiting for items are kept on one note in Notes
  • Someday/later items are stored like in the list based setup
  • Links between actions and projects are created using DateMan's link mechanism

It should be possible to achieve the same setup using just the built-in applications, but that would lose two important parts: Linking between actions and projects, and using context folders for actions. I am actually using More Folders and Super Notepad to further improve the setup, e.g. sort notes not by creation time but by title, see more notes via the one-line overview, or be able to use more folders for contexts.

The problems with the list based setup are solved quite nicely:

  • In the project review, each note which has a link is assumed to have a next action
  • It is easy to navigate between actions and projects
  • Since projects are stored individually, more information can be added to them

I still wanted to fix some minor problems in this setup though:

  • The link indicator is not visible in the Notes overview, making the project review more cumbersome
  • If a project is linked to not only actions but also other information, the link indicator cannot be used to show whether a project has a next action
  • The number of steps to create a next action were still too high, especially establishing the link between action and project takes too many steps

I solved these issues by creating dedicated Project Stationery. It adds a new action menu item to quickly create a next action, and shows a slightly different abstract in the overview. The overview shows an exclamation mark icon if one of the links for a project points to a to do item, and it also shows the link indicator. Creating a next action uses the currently selected text in a project note as the text for the next action, and it also allows specifying the folder under which the action is to be stored. Links between the action and the note are created automatically.

Dedicated Next Action List

One issue which continued to bother me with the previous setup was the disconnection between actions and projects. The linking mechanism provided by DateMan turned out to be less stable and more cumbersome to use than expected.

In addition to that, the usage of the To Do list (either built-in or in DateMan) for next actions seemed like mixing the "hard landscape" with the projects and actions. A clearer separation would have been better.

The result is Nitch, a simple application which continues with the concept of using Notes as projects, but does away with the separate To Do list concept. Instead, Nitch uses checklists as projects, and considers any checked item on a project as the next action. This makes assigning next actions very fast. Project abstracts in the Notepad overview are flagged if the project has a next action, this helps to quickly check for projects without actions during the review phase.

Next actions are then showed in a separate application, which is the main view during the day. From there, actions can be marked as complete, and project notes can be opened.