Something is Happening here at Geist Interactive

Hello there 🙂


We have some exciting news to share with you. Geist Interactive has merged with the Proof Group to form Proof+Geist (the + is silent). This is an acceleration of our decades-long mission of empowering people to do great things, a mission we have always shared with the people at the Proof Group. Together, as one team, we are very excited about what’s ahead.


Please see the attached press release, and visit us at!

Add-Ons, the Complete (and almost TMI) Guide

The most recent update of Claris FileMaker (19.1.2) includes add-ons. Finally. A calendar, a timer, a kanban board, and much more are part of the actual FileMaker product, built as add-ons.

These add-ons are designed to be fully functional with just a little bit of set up. Each add-on contains layouts, scripts, custom functions, buttons, web viewers, and JavaScript code to give a complete package of functionality. There’s so little to do with each add-on; it’ll just work. Like a portal or a button bar, you need to point the add-on to specific layouts and fields and found set of records. It’s really simple to get these working right away.

And for most people, that is good enough. Anyone can install a kanban board, direct it to find certain records in a table and display those records neatly in one or more columns. No more thought needs to be given to the add-on. It will just work. They’re as close to ‘no-code’ as is possible.

There’s two benefits to the fact that an add-on just works: 1. A lot of functionality value is added to your app within a few minutes, and 2. You can turn your attention to other use cases to complete your work faster.

Just Get Started

In case you want to just get started in using the add-ons, I’d recommend you read these few posts. They’re the quickest way to understand the bare bones workings.

In Case You Want to Learn More . . .

However, there’s a lot inside the add-ons that you might want to know–for your own knowledge and to be able to tinker with and extend the functionality somewhat. So these entirely-optional series of blog posts describes the inner-workings of the add-ons generally. Over the series we’ll also discuss some of the specific add-ons; we’ll give you tips on how to work with it most efficiently.

Here’s the planned list of blog post topics:

How Add-ons Work

View Post

Their universal and self-working functionality, their script and layout structure, and their modularity.

Filtering the Data

View Post

By default, the add-ons return all data, but you can limit the found set by applying a filter. We explain how.

Refining the Find

View Post

The Find Mechanism in each of these add-ons is simple to understand. It does all the work, but you may want to know more about it.

Refreshing the Data

View Post

Sometimes you want to force a refresh of the data, whether after an event such as a find or a record update. Here’s how you can do that.

Using Multiple Instances

View Post

You can use many instances of a single add-on in a file or on the same layout. This guide shows you how that works.

Configuring the Add-ons

View Post

Some add-ons have some complex configurations. Here we point those out and clearly explain how to configure them.

Add-on Events

View Post

All add-ons have events tailored to the experience. Here we talk about those and how you can adjust the Events script.

Required Fields

View Post

Most add-ons require fields both defined in the table and present on the target layout for them to work. Here we list those fields.

Refetching the Data

View Post

Many add-ons are set to automatically re fetch the data, so any changes made by another user will be displayed in the add-on.

Learn All About Add-ons, or Just Use Them

I’ll reiterate, the add-ons are complete in functionality, and most of the time you don’t need to know anything about what I’ve listed above. The add-ons will just work, and the configurations are minimal and done within a user interface rather than in scripting or schema. However, we want to give you all the information. Consider these posts an ‘under-the-hood’ kind of discussions where we talk the nitty-gritty.


So stay tuned. We’ll release these in small sets so as to not overwhelm you with things to read.

If there’s something else you’d like to know about that isn’t listed above, please shoot us an email at and we’ll get your request written up.

JavaScript at FileMaker DevCon 2019

My username on the FileMaker community is “jeremy_fm_js”, and I’ve been known to advocate using JavaScript in FileMaker for a few years now. It might be interesting to be typecast into ‘the guy that always talks JavaScript’ (I don’t always recommend JS in my posts in the community), but I advocate for many good reasons. Some of them are reasons I’ve stated before, but also, there’s a few new ones I’ve thought of in the past year 🙂 If you need an escape hatch–this is, if you need to build an interface that is more interactive than we can do using ‘idiomatic‘ FileMaker–we can consider JavaScript, and we can consider learning the language. To help you learn JavaScript, JavaScript is part of FileMaker DevCon.

Why JavaScript?

The answer to this question is: why not JavaScript? There’s a lot of innovation we can bring to custom apps using the language native to FileMaker. JavaScript and JavaScript libraries brings thousands of testers to its foundation. I’ve written about all this before.

More reasons

FileMaker itself seems to be giving some weight to JavaScript in the platform (the entire platform, of course). There are two pieces of evidence. First, exploring JavaScript, for the third consecutive year, is part of FileMaker DevCon, the FileMaker conference. Along with APIs and Zapier and microservices, attendees will have the chance to see and experience what JavaScript can do in our apps.

Secondly, JavaScript is specifically mentioned in the product roadmap. In the past it’s been rare to see something so ‘outside’ of FileMaker be mentioned in the FileMaker plans, but there it is. So FileMaker, Inc, and my friends in the product-development team, must have some special plans for it.

The roadmap states: “Within a web viewer, directly call JavaScript from FileMaker scripts and vice versa.” That’s a very amazing idea. We will be able to solve certain web viewer problems with this functionality and give more control to FileMaker interacting with the JavaScript code.

JavaScript at DevCon

All day pre-conference training

This year I have the honor of leading folks in a full-day training of FileMaker & JavaScript. We will work together for six hours to talk about the following objectives and concrete activities.

Learn the basics of the JavaScript language

We’ll work together on exercises that teach us the basics of the language. We’ll talk about JavaScript concepts, and we’ll connect what’s true about JavaScript with what we already know in FileMaker.

Each exercise comes with one or more extra practices. We’ll do those to drive the point home.

Identify the peculiarities of the web viewer object on different devices

The web viewer object in FileMaker is powerful, but it is quirky. We have to understand its needs for each device, so as we practice and exercise, we’ll talk about how the web viewer works differently in different operating systems.

Integrate JavaScript libraries into any custom app

The fun of this day will be to spend time putting charts or data tables or any number of other libraries into our apps. We’ll learn how to do this from scratch. We’ll also review the tools out there that make this part very easy.

Just so you know: In order to work with libraries, we need to know a little JavaScript. We can’t run until we learn to walk.

Learn to communicate between JavaScript and FileMaker easily

The FM WebViewer Bridge framework is an important last-piece of the puzzle. It solves quite a few problems when working with the web viewer, and it provides a less jarring experience for your users. We’ll examine how this framework works.

We will work through examples and practices to learn more about how we can use JavaScript, and it will be a productive day. Attendees will learn a lot about how to use the language. We won’t be JS experts, but we will at least know a bit more of our way around its use in FileMaker. I have two ultimate soft goals:

To be comfortable enough with JavaScript we can look a JavaScript library in the face and not run away screaming in terror.


To expand our horizons of what is possible with FileMaker and JavaScript.

The six hours will be more than enough time to get our feet wet. If you haven’t signed up yet for this training time, I encourage you to give it a consideration. JavaScript brings to our fingers much power, and this session can help you see how to harness that power.

Discussions throughout the week

I wish to continue the JavaScript discussion well after the training session ends (after we’ve had a chance to recover from the workshop). Last year I was available to talk shop and sat with a few folks to talk one-on-one about how to integrate a chart or a data table into their in-production apps. That was a blast. So this year I wish to continue that. While at the booth or at food time or in the hallway, I’ll be available to talk with folks about their use of JS in their apps. So feel free to find some time with me and we can continue to discuss this innovative tool.

JavaScript after DevCon

The fun doesn’t end when FileMaker DevCon 2019 ends. Oh no. Energized from that experience, I’ll continue to talk about JavaScript and FileMaker. I’d love to do a follow up training session with interested folks to continue to learn more about the language and how to use it in FileMaker. So stay tuned to this blog and our Twitter page for more information.

Preparing for DevCon

If you do plan (or are thinking about) on joining me for FileMaker & JavaScript, please take a moment to download the file (below) and test your setup (computer, browser security settings, FileMaker version etc) to see if all will go well with your time. Basically click some buttons and confirm you see the web viewer user interface and interactions. Those running macOS will be fine. Windows users should really test it out.

I want you to be successful in the session. The file here contains a small sample of what we will do; all the items you’ll test here we want to make sure work. If you download the file and run thru the tests and all is good, you’ll have no issues with the work we do during the training. If you do have issues, please reach out to me at and we can work on finding a solution so that you can attend and learn and exercise your innovative spirit.

Don’t worry if your copy ‘fails’. I have a plan in case you can’t view the C3Chart or the DataTables or the PivotTable. The only extremely-vital one is the Code Editor test.

See yah in just a month! And get ready for JavaScript at FileMaker DevCon.


The following list of downloads reflects what we did during the FileMaker & JavaScript session. More is coming soon.

JS Test File: test your machine to be ready for the training

Session Slides: The slides we used to talk about JavaScript and FileMaker and the web viewer.

To view all the resources we used and to view tutorial videos walking through each exercise we did during the session, go to this page.

Geist Interactive At FileMaker DevCon 2019

FileMaker DevCon 2019 is fast approaching. There’s less than three months left, and we at Geist Interactive are busy, getting ready for the conference. Todd Geist and myself–Jeremy Brown–will attend (this will be our 20th and 8th time respectively) and spread the good word about JavaScript and the Workplace Innovation platform. We will be busy during the week, but will always make time for chatting about FileMaker or JavaScript or any other tech topic. Read on to see what we will be up to in Orlando, FL.

Conference Sponsor

Geist Interactive is proud to be a sponsor of this year’s FileMaker DevCon. We believe the three-day conference is great for every innovator out there. FileMaker DevCon 2019 will be full of great people, great innovations, and great food. We want to give back in the form of sponsorship so that all developers can learn as much as possible and make great connections.

Training Day

For the second year in a row, I will lead folks in a training session titled “JavaScript for FileMaker Developers“. This full-day session (upgraded from a half-day last year) will focus on how to use JS in our FileMaker apps. Attendees will spend time working on exercises in the JavaScript language. Each person will build a complete integration of a data table or a chart into a custom app. And everyone will learn how to work with the FileMaker Web Viewer object (which can be a bit prickly in some situations). Finally, we will focus on advanced topics like how to communicate to the JavaScript from FileMaker without causing a rude flash of the web viewer.

Our playground for the day.

I am dusting off my teaching skills and pulling out my manipulatives so that everyone–from the JavaScript beginner to the more advanced person–can learn something and walk away with a good set of next steps. Every FileMaker developer can (and should) use JavaScript as another tool in their apps. Join me in this session and learn how to use this powerful tool.

WorkPlace Innovation

Todd Geist is extemely a little obsessed with Workplace Innovation and FileMaker. He’s written about the beginning and the continuation of innovation with each incremental release of the platform. So at FileMaker DevCon 2019, Todd gets to speak about what he sees in the current status and the future trajectory of the Workplace Innovation Platform. Here is a description of his sessions:

Why a Workplace Innovation Platform?

What’s so special about a Workplace Innovation Platform? You’ve seen the videos, you’ve read all the marketing material, but practically speaking what is that makes a Workplace Innovation Platform standout from other options? We are going to look at the current state of business and work group innovation, and learn through a series of examples and mini case studies why FileMaker, as the leading Workplace Innovation Platform, can be so effective in driving business innovation.

What’s Next in Workplace Innovation?

Workplace Innovation doesn’t stop. Neither does the flow of exciting new technology that the FileMaker Workplace Innovation Platform makes available to us. In this session, we are going to look at some of my favorite bleeding-edge techniques, tools, and integrations that really make the FileMaker Workplace Innovation Platform shine. Come and see what the future looks like. There will even be some fun demos you can download and try on your own.

These two sessions are going to be lively and challenging and full, so you may want to show up early to get a spot.

No matter the size of the booth, we’re happy to talk all things Workplace Innovation Platform

Hanging at the Booth

Todd and I along with Tonya (another member of the team) will spend their time at our annual booth in the exhibit hall (though we do wish it were located down by the pool). We always welcome folks to come and stop by and talk anything you want. We’ll demo our products (FMPerception, Otto, WidgetStudio, GoDraw3, and many others) and our custom development offerings. So stop by for a spell and chat us up. Bonus points if you come ready to talk about, A. JavaScript; B. JSON; C. FileMaker Modules; D. Innovation in FileMaker.

Vendor sessions

At FileMaker DevCon 2019 we will feature FMPerception and Otto in two separate vendor sessions. Dave Ramsey will demonstrate the value added to your development using the only Realtime Developer Intelligence tool. He’ll open your eyes to the major features as well as the intricate details that really makes it more intelligent.

Todd will demonstrate what the best Dev Ops tool “Otto” do for you. He’ll walk you through how Otto can help automate the tedious and error-prone process of deploying, migrating, and monitoring solutions.

Check out the schedule as we get closer to DevCon. Stay tuned to us on social media for updates as well.

Packing our Bags (soon)

We’re getting ready for FileMaker DevCon 2019. We’re excited about all the innovations that will be on display and shared throughout the week, and we can’t wait to share a few of our own.

If you’ve never attended, check out my blog post on attending the conference for the first time from last year. Eventually he will post a new one with an updated theme 🙂

See yah in just a few months!

The Context Podcast by Proof+Geist

The Context Podcast: Unlocking Efficiency with SimpleQ

The Context Podcast: Unlocking Efficiency with SimpleQ


Martha Zink 

Todd Geist 

Corn Walker 

Mike Perley


Welcome to this episode of The Context Podcast where we explore the incredible capabilities of SimpleQ!

Join us as we delve into the intricacies of SimpleQ, explaining its seamless task handling and compatibility with various systems. Discover the advantages of this approach and how it revolutionizes business processes. Additionally, we explore the origins of SimpleQ, discussing the hybrid PubSub and queuing system that gave birth to this remarkable tool. We also shine a spotlight on Otto and its crucial role in accepting webhooks from third-party systems. See how Otto seamlessly integrates with SimpleQ to streamline data flow and enhance communication across different FileMaker apps.

Tune in to The Context Podcast and embrace the efficiency of SimpleQ—a game-changer in the world of FileMaker and business process automation. 

You can find this episode on YouTube, Transistor.FM, or your favorite podcasting platforms. 

PauseOnError 2023 registration opens soon

FileMaker enthusiasts! We are excited to announce that registration for PauseOnError FileMaker Summer Camp* 2023 opens on Monday, May 8 at 12pm ET.

This year’s event will once again be held at the beautiful Kaplan Mitchell Retreat Center, located in Clayton, Georgia, from October 3 to October 6, 2023.

Last year, we interviewed folks about their experience at PauseOnError. You can listen to those interviews here or you can listen to abridged The Context Podcast versions: Part 1, Part 2, and Part 3

PauseOnError’s FileMaker Summer Camp provides an opportunity to immerse yourself in all things Claris, FileMaker, and beyond with a focus on learning, connecting, and having fun. Whether you’re a seasoned developer or just starting out, there will be something for everyone at this event.

Accommodations are limited, so don’t wait to secure your spot. Click HERE to learn more!

*Summer Camp… in the fall? Totally. It’s not just a season, it’s a vibe.

FileMaker 2023 Compatibility Notice

The release of the new Claris FileMaker 2023 update has been long-awaited by developers and users alike. With many new features and enhancements, it promises to make the already robust database platform even more powerful and efficient. 

We also recognize that with new updates, compatibility issues can arise. Here are some additional details about how this release affects our products.


  • Versions 3.5.2 and earlier 
  • Update Required 

Otto will require version 3.5.3 to work with FileMaker 2023. It is available for download.


  • 19.0.0
  • Works, with caveats*


  • 1.0
  • Works, with caveats*

*FMPerception and FMComparison will work with FM2023 DDRs, but information on certain new features may be incomplete in reports from FMPerception and FMComparison. For example, the new “Perform Script on Server with Callback” shows up, but FMPerception doesn’t yet recognize the Callback Script. We are working on releases of both FMPerception and FMPComparison that will address these issues.

  • All versions
  • Supported

There are no known LedgerLink compatibility issues with FM2023


  • V1.3.2
  • Supported 


  • Supported 


  • Supported 

It’s always a good practice to check with the developers of any tools for updates or known issues specific to the latest version of FileMaker. Additionally, it’s important to thoroughly test any third-party tools or plugins before implementing them in a production environment, especially after a major software update.

If you have questions about FileMaker 2023 compatibility issues, contact us at

Reflections on FileMaker in 2023

I picked up my first copy of FileMaker 3 and wrote my first little database app in 1998. Twenty-five years later, I still find myself eagerly anticipating the next new release, hoping to try out the next cool feature that promises to keep this business of solving problems with software fun. 

A lot has changed in the intervening years. The product has evolved and made significant transformations, gaining power and features. FileMaker started as a tool that hobbyists and professionals depended on. Today, it is also unequivocally a platform for professional software developers. I can’t think of another development platform with the same legacy and endurance as FileMaker. Many all-in-one database and business application development products have come and gone. FileMaker is still, by all measures, going strong. I think this is worthy of celebration and study.

In the coming days, you will read and hear about many of the cool features that Claris is releasing with FileMaker 2023. There is a lot in this release, and I am going to single out one of my favorites–the OnWindowTransaction script trigger. Note: non-technical readers might want to skip to the next section.

OnWindowTransactions in FileMaker 2023

Here’s how it works per the release notes:

The new OnWindowTransaction script trigger creates a JSON object whenever a window’s transaction completes successfully. The JSON object includes the file name, base table name, record ID, operation, and contents of a specified field (or a field named OnWindowTransaction if none is specified) in the base table for every operation within the completed transaction.

Naturally, I find anything to do with transactions pretty exciting, though I think this one is subtly powerful. New possibilities for audit-logging immediately come to mind. But this feature also feels like the closest thing we have to an events handler that can be bound to our app’s data “objects.”

Imagine if we had a CONTACTS object that is modeled with several related tables like so:

In this example, I have created a JSON object in a field called _JSON. This JSON includes data from the CONTACTS table and its related ROLES and PARTY tables. 

We can then hook up a script to that OnWindowTransaction trigger to do a thing such as publish a message to another file or just show a dialog message with the contents of the JSON payload along with the operations details of the transaction every time a CONTACTS record was created, updated, or deleted(!).

For example, after I modified James Bond’s Contact::name to ‘Jane Bond’, FileMaker fires off a script with the contents of the _JSON field from the CONTACTS table:

The amazing thing about this is that this is layout agnostic. This is a Window-level trigger which, for all intents and purposes, means it will work on any layout. Total. Game. Changer. 

Let that sink in.

Yes, you can probably do this today with a lot of care and effort, but doing this kind of thing with OnWindowTransaction would be a huge time saver–it’s simpler and more elegant. 

It is modern.

FileMaker can now natively publish changes to data. Imagine the possibilities if we could couple this power to a simple pub/sub system or message queue to distribute those changes in a non-blocking way to other FileMaker apps or 3rd party integrations. Conveniently, we happen to write just that thing for FileMaker; it is called SimpleQ, and it is free.

But wait, there is more

Aside from the above-mentioned OnWindowTransaction trigger, we are also getting a bunch of eye-opening features such as the new ability to do callbacks with Perform on Server scripts. There are also dozens of important bug fixes and stability improvements, not to mention the numerous features aimed at scaling Server performance. 

This is a doozy of a release.

I’ll admit I wasn’t sure about the decision to call it “FileMaker 2023” but, in retrospect, it makes a ton of sense. At its core, FileMaker 2023 it’s still very much the FileMaker we all know and love. But juxtaposed with the changes that have come before, this release feels revolutionary–it feels like a release designed for modern software development.

Speaking of modern software development, we’ve previously outlined some of our ideas on the Modern FileMaker Revolution, here, but the gist of it is this: if the legacy FileMaker development is about making monolithic do-it-all database apps, modern FileMaker is partly about lightweight, highly performant apps that work within a network of other applications, be it cloud-based SaaS apps or traditional on-prem business ERPs. Modern FileMaker development practices emphasize ideas around loose-coupling and encapsulating complexity to make things easier to maintain; taken all together, the developer-centric features of FileMaker 2023 like OnWindowTransaction, and callbacks help us do exactly that.

Be warned. The release notes are long, but one thing seems clear–Claris remains deeply committed to the FileMaker product line even as it is working to expand the Claris platform; and, I think, for good reason. Twenty-five years since my first “File…New” command, and years of professional consulting and development work with so-called serious software development stacks later, FileMaker is still the first tool I reach for when I want to solve a business problem. 

Congratulations on a great release, Claris! Learn more about FM2023 here.

The Context Podcast by Proof+Geist

The Context Podcast: Claris 2023


Martha Zink, Todd Geist, and special guest, Rick Kalman.


In this episode of The Context Podcast, Martha Zink and Todd Geist talk to Rick Kalman from Claris about the launch of Claris FileMaker 2023

Together, they discuss the upcoming changes to the platform—including the switch to a year-based naming scheme, significant performance improvements, and the availability of Claris Connect on the free plan. With stronger authentication protocols, greater scalability, and improvements to backend infrastructure, FileMaker 2023 promises to be Claris’s best release yet!

Also featured: Todd’s dog, Clark, who is recovering from knee surgery and is spending his convalescence providing additional commentary in the form of background snoring.

You can find this episode on YouTube, Transistor.FM, or your favorite podcasting platforms.

Managing dynamic FileMaker filenames

There are a few scenarios where you may need to change the filenames for your FileMaker custom apps.

For example, you might be hosting your development copy and production copy on the same server. Since FileMaker Server does not allow you to host two files with the same name you have no choice but to name them differently, eg,“My_CRM” and “My_CRM_Dev”.

Or perhaps you’re maintaining one master codebase on the development server and pushing that codebase to one or more servers with a different name in production. This is a common scenario for businesses that provide custom software for a vertical market using FileMaker and the Claris platform. This also applies to businesses where different locations or offices maintain separate custom apps, but development happens on a single file. In this case, “ERP_Main” on the development server becomes “ERP_ClientA”, “ERP_ClientB”, etc. for a vertical market solution or “ERP_Houston”, “ERP_Jacksonville”, etc. for a business’s multiple locations.

But this can get tricky! If you have a FileMaker solution made up of multiple files, you link them as FileMaker external data sources. If you have “ERP_ClientA” and “CRM_ClientA” files that share schema, you want to make sure that your connections don’t break during a FileMaker data migration.

The good news is Otto supports migrating a file and changing its name during the migration process, making it a preferred tool for data migrations. The other good news is that FileMaker supports global variables for naming external data sources.

Getting started with external data sources

External file references are schema and are defined by specifying the path to the data source in Manage > External Data Sources.


Even though Otto supports changing the filename as part of the migration, it cannot update hard-coded file paths. Whatever you define in the file is what FileMaker uses in the cloned/copied files.

FileMaker 16 introduced the ability to set dynamic data sources, allowing you to  specify a global variable for your data file path:

Cool! Now SolutionA can have a different reference to the data file than SolutionB.

Defining dynamic data source paths

One of the first things a FileMaker solution does on open is to establish its data source path. The key phrase here is “one of the first things.” A dialog will show if FileMaker  is not successful in resolving a path:

Once defined, dynamic data sources cannot be modified in the same session. The solution must be closed and reopened. That is, if your use case is to define dynamic data sources based on the account that logged in, the solution must be closed and reopened to redefine those references. The re-login script step will not be enough.

Here are the rules we’ve found to be successful in defining your paths before FileMaker tries to resolve them:

Use a layout that has no dependencies.

Open your solution to a layout that does not require any links to an external data source. Use a local table and open the FileMaker file to a splash screen layout based on this table. This layout can be blank or have the solution name and company logo. Its purpose is to let you define the external data source before those dependencies take effect.
Starting in FileMaker 12, you can specify the first layout in File > File Options.

Do not reference an external data source in the opening script 

Most FileMaker solutions run a script when the solution opens, by way of the OnFirstWindowOpen trigger. Use the Perform Script to call sub-scripts that will run in the following order:

  1. Set external data sources
  2. Run startup process

With this script structure, you will avoid FileMaker’s attempt to resolve any external file references as soon as it reads the OnFirstWindowOpen script into the call stack. You can safely refer to dynamic data sources in any subscript to the OnFirstWindowOpen script, such as “Startup” in our example. 

The Set External Data Sources script

There are a couple of ways to define external data sources. One way is to store the file paths as data in a single record table. That will survive a migration.

Another is to namespace the filenames in such a way so that paths can be defined based on parsing the filename.

Whatever method you choose, as long as this script is called before any external data sources are referenced, you will be all set.

Gotchas: Remember FileMaker will look for a data source if needed for a value list or saved Find request.

Startup script

Now that the dynamic data sources are defined, the startup script explicitly opens the supporting files.

This is an essential step, because as detailed in the FileMaker help documentation, “a file is opened with a hidden window via a relationship or a script, this trigger doesn’t activate until a window is created directly. However, performing a script in another file does not activate this trigger in that file even if the script creates the first window for that file.”

Does it get more complicated? Why yes, it does.

We often work with solutions that have complex and variable referenced dependencies. In these situations there is often one file that controls the opening of the rest of the solution. If there isn’t one you can make a special Launcher file that does nothing but controls the opening of the multifile solution.  Or just pick one of your files to serve this purpose. The key point is that every user must use that file — and only that file — to launch the system.

Once you have established which file will control the opening, you can set up an OnFirstWindow opening script that kicks off the controlled file opening process. That controlling script should first establish its own dynamic external file references, by setting the variable(s) as described above, and then calling a Script in other other files. Those scripts in the other files should do nothing but set their dynamic file references (if they have any). They set the dynamic reference variable, and use Open File to lock the reference in place.  You might consider calling those Scripts, “Set References”

Following this pattern will ensure that you are establishing dynamic file references in each file that requires them BEFORE you do anything else.

Once the original controlling script has run through this controlled opening, it can go about doing whatever else it has to do to start the system and put the user in the proper place.

Proof+Geist logo

St. Louis User Group with Todd Geist

Join us virtually on Tuesday, April 18th, for a virtual user group meeting hosted by Jay Sayers of Skeleton Key and discover how Otto gives you superpowers for your FileMaker server!

Todd Geist will be leading a presentation of Otto’s current capabilities, and better yet, he will also give attendees an exclusive first look at Otto v4.

After the presentation, an Open Forum segment of the meetup will allow attendees to ask questions, share problems, and showcase their projects to the group, with the added benefit of getting answers and feedback from collective experts. This segment is open to everyone– including newcomers to the FileMaker Platform, who can get an exciting introduction to the platform’s possibilities from the friendly community.

You can RSVP here to receive the link; we can’t wait to see you there!

Update: Thank you to everyone who attended this meeting. You can now view the recording on YouTube. We hope to see you at the next user group meeting!

Databuzz’s DocuSign Webhooks using Otto

Hello! We’re excited to share that Databuzz is doing some very cool things with Otto, as they’ve recently discussed on their blog.

Databuzz is an FileMaker integration expert and awesome Claris Partner based in Sydney, Australia. They announced support for using Otto Webhooks as an alternative to the PHP files that they supply, beginning with their fmESignature Link product (DocuSign Edition).

“Otto’s built in support for webhooks means you can use Otto to act as the receiver of the incoming requests and then perform additional actions, including creating new records in a FileMaker solution, populating fields with data from the webhook request and performing a FileMaker script.” 

Andrew Duncan, Databuzz

This is exactly the sort of use-case we had in mind when we added the webhook receiver to Otto. You can read the Databuzz guide to setting up DocuSign webhooks with Otto here.
We’re thrilled to see the cool things that Databuzz is doing with Otto and we hope you are too! Click here to read about the other great things Databuzz is doing by leveraging Otto.

When less smart is more smart

I love my smart home. I also feel really fortunate to have it, especially given how my wife and I are complete opposites when it comes to technology. She admires the simple practicality of pen and paper, while the computer nerd in me always tries to squeeze out any efficiency in my everyday process (which is lived mostly on a computer screen).

It started with a light switch

When we moved into our new house last summer, I was able to convince her to buy some smart light switches so that we could turn off the light or control the fan in our bedroom at night without having to get out of bed or stumble back to the bed in the dark. Those few light switches quickly snowballed into a few more and a few more until now we have the opposite problem of never turning lights off manually and probably using more electricity than otherwise in the process!  

But we continue to justify this smart home overhaul as an acceptable hobby. It’s a fun project for me to set up the smart routines or configure everything just so. And I’m always careful to install manual overrides for all our smart appliances, so we won’t be left in the dark when things inevitably break, and we find ourselves unable to control devices with our phones or voices.

Speaking of the dark

(You probably saw this part coming…) One morning, I woke up to a seemingly innocuous notification—my wifi network in my home had auto-updated. “This happens all the time, no big deal” I thought. But then I noticed my kitchen lights hadn’t turned on to greet me that morning. And several of my smart devices were coming in as “unresponsive” in my Home app. My smart home was collapsing! It took me several weeks before I had the time to really dig into the troubleshooting phase and finally fix the problem. But along the way I did more damage to my smart home than was necessary and reset things such that they may never be the same again.

“Smart enough” devices

In contrast to my smart devices, I also installed a few “kinda smart” devices that don’t connect to my Wi-Fi at all. Just simple motion-activated lights in some closets to replace the old pull-chain fixtures. Again, these may be an unnecessary indulgence, but still solve the problem of forgetting to turn off the light when leaving the closet or rummaging around in the dark just because you think you’ll be quick and you know where it is and you don’t want to have to remember to turn the light back off… But these new motion lights just work! They are smart in the sense that they are always on when you may need them but never when you don’t, yet they’re more reliable, cheaper, and easier to troubleshoot than my many other over-complicated smart home gadgets.

Over-engineered development

The fact that you can do just about anything with software is both its biggest asset and its biggest challenge. It gives us the potential to solve just about any problem, in nearly any way we can imagine. With enough time and resources, we can build essentially anything we can conceive of. 

This is a huge risk because it means we have the potential to go down paths that aren’t even solving the right problem. When I started my smart home, I was trying to solve the problem of inconvenience—having to move from a comfortable spot to change the power state of the lights. That led to the deployment of a solution – the smart light switch! The temptation to take that solution and continue to apply it to every adjacent-seeming problem was high. We could have smart switches everywhere!

However, when I really considered the problem I was trying to solve with the closet light, I realized that it wasn’t exactly the same as the other lights. Here, I wanted something that would turn on when I was rummaging and off when the space was idle. While I could have programmed a smart switch and motion sensor combo to solve this problem, in fact, there was already a widely available, off-the-shelf solution that was less expensive to deploy and had much fewer dependencies to maintain over time for it to continue functioning.

“Smart enough” development

This got me thinking about design processes for technical solutions, and how we often end up with a simpler implementation than we imagined in the beginning. We should never discount the “simple solution” just because it doesn’t feel as robust. In fact, we often steer our clients toward simpler solutions, testing each assumption to suss out where complexity is really needed.

Everyone always wants the latest and greatest, shiniest new thing that has the potential to solve all their problems far into the future. But those solutions take longer to build, and therefore longer to have to deal with an old problem of something not working as efficiently as it should. Even then, when the over-complex solution is finally deployed, any change to its functionality that wasn’t deeply considered beforehand may take exponentially longer to implement due to fear of introducing regressions to the solution.

By getting clarity about the actual problem, we’re able to ask if a more simple solution would be “good enough,” or even better, at solving the problem. Sometimes the simple solution is much better in many ways, keeping your lights on only when light is needed.

The Context Podcast logo

The Context Podcast: Transactions in FileMaker 19.6


  • Martha Zink 
  • Todd Geist
  • Corn Walker 
  • Peter Vinogradov


In this episode of The Context Podcast, we are joined by Todd Geist, Corn Walker, and Peter Vinogradov for an epic debate between Team Pro-Transactions and Team Anti-Transactions. They dive in and discuss the benefits (and bad habits) that come with transactions in Claris FileMaker 19.6. 

FileMaker’s 19.6 version release brought simplification and cleanup to the developer side of transactions, creating new commands to cut down on multistep processes and turning hard-to-read error-catching code into something legible. This is certainly an update focused on improving the lives of FileMaker developers. All this, combined with the caveats brought up by the (tentatively) Anti-Transactions Team, help round out the conversation. 

This podcast is available on Transistor.FM, or any of your favorite podcast platforms The video is available on YouTube. 

Check out the rest of our 19.6 series: