The Workplace Innovation Platform we know, called FileMaker, is exactly that: A platform. There’s many components in the platform. As we add those components to support all the clients’ needs in the custom app, we have to take special care about each. One thought to keep in mind is the script step compatibility. We have to make sure each step in each works in the platform in which we intend. So let’s take a look at FileMaker script compatibility.

FileMaker Go, FileMaker Pro Advanced (on macOS and Windows), FileMaker WebDirect, FileMaker Server, and the FileMaker Data API work very similarly. But there are some differences whether or not script steps work. Some steps are not supported in a part of the platform, and some steps are partially supported. It would be mind-boggling to remember which steps work where, so the script workspace gives us a tool to use.

Many of my script steps do not work for the FileMaker Data API component.

At the top right of the script workspace is a button that opens this dropdown. We can use it to examine a current script to see which steps are not compatible with the selected component. You’ll see any incompatible script steps grayed out.

Additionally, we can use this dropdown to examine the script step list to see which steps are compatible.

So the lesson is: when we are writing a script, we should use the FileMaker script compatibility checker to make sure each step will work. We need to design scripts that are the best for each part of the platform. We need to review existing scripts to make sure each step will perform correctly in the chosen components.

Scripting smarter

Scripting compatibility sounds like a lot of work. Either I’ll have to create one script per component to do the same thing, or I’ll have to have a lot of logic inside a script to handle all the possible places a script will be run. But it really isn’t too hard. And if you think about it, what’s worse: more work or incorrectly-performed scripts?

Here are some strategies you can use to ensure you’re scripting smarter: efficiently and effectively.

Get to know the components

Many seasoned developers have an encyclopedic knowledge of the entire platform, and that includes knowing which steps are compatible with a part of the platform. This simply comes with experience. I don’t think it’s that these developers know all the compatible steps for, say, FileMaker server, but they know what FileMaker Server can and cannot do.

For example, we know two ways to run scripts with FileMaker Server: Perform Script on Server or Schedule Scripts. Each of these uses the scripting engine inside Server. It opens an instance the custom app only in memory. No UI is drawn. So we have to consider what this means. There’s no window, so the Move/Resize Window step is useless. That’s why it’s not compatible with server. (if you do use this step on server, nothing bad will happen. We’ll discuss its consequences further down).

Likewise, the script step Get Directory does not work in FileMaker WebDirect. We know this because that component does not have access to a client’s file system. FileMaker developers in the game for a long time know this.

One caveat

FileMaker, Inc. continually updates their platform’s functionality, and thus FileMaker script compatibility changes. Script steps that were not compatible in a part of the platform in the past are now compatible. The script step “Save Records as PDF”, back in the old days of FileMaker 15 and earlier, was not compatible on server. Since FileMaker 16, it has partial support.

Once you know how a component of the platform performs or works, you can more efficiently pick those steps that will work and work around those steps that you need that won’t work (if possible).

Write Component-targeted scripts

This strategy involves writing a script for each component that will be used. If I need a process to run using the FileMaker Data API, I should write a script just for that process and component. Even if that same process is used in FileMaker on Windows, there is a benefit to having two separate scripts that do the same thing (roughly) that are customized to that component’s script compatibility.

My script workspace might have folders for each component:

  • Go
  • API
  • WebDirect

and so forth that hold specific scripts.

To start, I’d build a script that works completely on the most common component used in my custom app. I might start with FileMaker Pro Advanced on macOS. I’d build the script, duplicate it, and adjust it for the Data API as necessary.

In-Script Logic

Another strategy to use when working with FileMaker script compatibility is to use logic in your scripts that skip over incompatible script steps for any component. This involves checking for the component that is running the script, and then, at each step in question, skipping over it or performing a different set of steps that do work for that component. The functions Get(SystemPlatform) and Get(Device) are good candidates for component-checking. There are also custom functions that provide this functionality as well. _IsWin will return 1 if a Windows machine is running the script.

The Consequences

When the FileMaker runs a script, it will skip over any steps incompatible with that component. Sometimes that isn’t a problem. Show Custom Dialog is not compatible on FileMaker Server, and Server will skip that step. That’s okay if the script step was meant to show a success message. If, on the other hand, the step included input fields which are used in the rest of the script, there’s a problem. So you have to consider each incompatible script step and decide if the script will break if the process is incompatible.

What is ‘Partial’?

There are quite a few script steps that have listed “partial” in the supported column. Save Records as PDF is one of those. It is partially supported in FileMaker Go, FileMaker WebDirect, and FileMaker Server & Cloud. It seems odd. Why would a step be partially supported? As with anyone’s enjoyment of brussel sprouts, support seems binary. No one ‘partially’ enjoys the gross-smelling green sphere.

Well it turns out FileMaker can support some parts of some script steps. These steps happen to be ones with many options. The Script Workspace is helpful in showing which parts are supported and which are not.

When we encounter a partially-supported step, we can use FileMaker’s documentation to review the partial stuff. (By the way, did you know you can get to the documentation by right-clicking on a step in the Steps menu and choosing “Help”? That’s cool.) The Partial information is found in the notes.

In this case, Save Records as PDF is supported, but the dialog will not show up when this step is run from FileMaker Server. So it is wise to review the notes for partially-supported steps.

FileMaker Script Compatibility: Write scripts with all the tools

FileMaker Script Compatibility is an essential part of every developer’s skill-set. Whether she knows how each of the components works and their functionality limitations or she uses the compatibility checker, it is vital that each script runs successfully and does what it intends to do in every part of the platform.

We need to do better logging in Karbon, both developer logging at design time, and process logging at runtime. This video covers some of the progress we have made towards solidifying our approach to logging.

Why not just use DBTransactions?

It is tempting to use the DBTransactions table as our log, and in fact, it includes many log-like features. However, DBTransactions is really about database transactions, not logging. Logging is really a separate thing, which has many nuances of its own. Conflating the two concerns is probably not wise in the long run.

Logging from within Transaction

The other problem is that you want to log info from within a transaction and make sure that data stays even if the transaction is reverted. So step 1 is to develop a log method for logging within the transaction. That “transaction log” can later be sent of to the main log, which we’ll get to later.

This feature is not yet “done”. More work needs to go into generic logging, and process logging. Stay tuned for that.

Karbon Info

Karbon is our free framework for building complex apps. We share rough updates like this from time to time because people have expressed interest in what we are doing. For more info on Karbon see here.

JavaScript libraries bring additional and deeper functionality to a FileMaker custom app that are not yet available inside the platform. One widget that I’ve used occasionally in the past was a Date Range Picker. This particular integration is pretty simple to set up and to use. It allows us to add a picker to our custom app that is customized to our locale and easily sends the selected dates back to FileMaker. So let’s study how to work with this FileMaker Date Range Picker, just as we’ve done now with DataTables and C3 Charts.

In this post, I’ll summarize the key points of the video and point out the sections of the 45 minute tutorial. Also in this video, we examine a few ways to spread this integration to any part of your custom app. It’s the first time we’ve talked about this specifically, but I’ll bring it up in a future video.

Here’s the file if you want to follow along and build a FileMaker Date Range Picker.


The video is 45 minutes. I walk through how to set it up, make a few mistakes along the way, but fix those in time. Here’s the breakdown:

  • 00:00–Intro and integration
  • 20:41–The Callback function: Sending the dates to FileMaker
  • 31:30–Setting up Options: changing how the date picker functions.
  • 38:57–Using in FileMaker: strategies for spreading the integration to many parts
  • 44:57–The Finishing Touches: Causing the picker to appear when the window loads

Key Points

Setting up the FileMaker date range picker

Here we go through our normal process of setting up a table to hold all the libraries, the HTML document, and the JavaScript function. We don’t need a data field since this is just a widget. I’m considering a sort of ‘generator‘ to help me create the fields and tables we need so that we don’t have to go through this tedious process every time. (FYI: There is another way that we’ll get into in an upcoming movie that deals with our Web Viewer Bridge Library).

We also set up the layout to be accommodating for us to enter and edit the libraries.

Interesting details

This integration came with a bunch of interesting little points that we may not have addressed before.

  • We built an input text box in the web viewer, and we added a font-awesome icon just to the right of the input box.
  • We used our knowledge of JavaScript to change the code just a little bit. That was fun.
  • The JQuery function $ (it really is a function) applies a date picker method to the input text box.
  • That date picker method: datepicker() is something the author of the library built for us. It is somewhere in the DatePicker library. We don’t have to worry about it. He’s tested it many times. It works very well. It’s like us calling a script from a separate file. We don’t have to understand it, we can just use it.

    A picture of the FIleMaker date range picker.

    There are options galore!

  • There are many options, and we could spend hours configuring this widget to our needs (for fun, not because we have to build each option).
  • What’s cool about the options is that one line of code:  “showdropdowns: true” is all it takes to add a month and year dropdown that updates the calendar to the widget. Or this one: “timePicker: true” draws and adds the time-picker functionality. Wow.
  • the Moment.js library handles date and time formatting for me. I don’t have to do any conversion of the dates when they’re brought into FileMaker. This is a great library I wish I could use more in everyday FileMaker work.

I’m only human

Throughout this video, I made a few mistakes. Here is a rundown of what I did, which happen to be the common errors anyone could make:

  • I forgot a comma in between object properties.
  • I would sometimes forget the closing parenthesis or bracket. This vexed me a few times. I mention in the video that it is best practice to write the opening and closing brackets or parentheses at the same time before filling in the function or options. You are wise to get the hamburger buns before putting in the meat and toppings.
  • Sometimes I put options in the incorrect place. The solution with this comes simply by understanding the structure of the JavaScript.
  • The order in which the libraries loads matters. In this case, the JQuery library needs to be loaded before the DatePicker library. And both of these are required for the actual function to work.
  • The Substitute Function in FileMaker is case-sensitive. “**JQuery**” is not the same as “**jQuery**”. So placeholder text and the text inside the substitute function must be the same.

A picture of my errors

Applying the FileMaker date range picker anywhere

We also briefly touched two ways to allow this to be used anywhere in your custom app. Since we’re dealing with fields in a table, we either have to establish a relationship or load the data into global variables or fields with global storage (global fields). I built this both ways. As FileMaker developers, we can understand the pros and cons of each way, but I’ll bring that up in a future video.

This is a good and simple widget. It is powerful and easy enough to use in any custom app. Give it a try. If nothing else, it’s good practice.

Download the files that I used and see how satisfying it is to build a fully-functional FileMaker date range picker widget. I’ll continue demonstrating integrations from my DevCon 2018 session. And if you haven’t yet, please join our FM/JS Slack channel.

We all want our custom apps to be faster, right? As problem solvers, we design our system and complex processes to happen quickly so that the user can get on with her task. Well one method we have at our fingertips is FileMaker Perform Script on Server. Let’s discuss this script step, its features and things to watch out for. As we study it and use it properly, we’ll use this script step like a boss.

Filemaker Perform Script on Server

This small-seeming script step was introduced in FileMaker 13. Its purpose is to, as it is called, perform a script on the server. Of course this only applies if a file is actually hosted. You can specify a script in the current file or external data source file, run it up on the server, and get back the result. We’ll look at why this was such a game changer below.

Perform Script on Server (P.S.O.S., as FileMaker devs like to call it) works in FileMaker Pro, FileMaker Go, and WebDirect. It is not supported in Runtimes, and it doesn’t make sense in Server schedules–scheduled scripts already perform on the server.

Along with the script name and the parameter, you can specify to “Wait for Completion”. We’ll get into this more later.

The Advantage

Complex tasks take up a lot of computing power and time when run against hosted data on a client machine. As of FileMaker 15, records are cached in the local machine, but FileMaker still might have to fetch new records, process them in some way, and then send the updated records back to the server. That’s a lot. FileMaker Perform Script on Server does the complex tasks right there on the server, where the records are actually sitting. There’s no transfer of data back and forth. Server simply does the work, then updates the client cache with any changed data. The difference in time between the same script running on the client and the server is noticeable.

With great power . . .

As with most things in life, when you’re given a great tool, precautions must be taken and your eyes need to be extra vigilant. Perform Script on Server, too must be handled carefully.

Who is performing the script?

When the PSOS script step is called, it opens the file on the server with the same security as the current user invoking this script step. If I log into the hosted file on my machine as “jbrown” with a privilege set of “HR”, any PSOS script I run will operate with those same security settings. The log in for PSOS is very similar as mine in terms of security, but nowhere is a UI drawn as I would see it on my machine. FileMaker Server can open the file and perform the script with no interface. This login also opens up and runs the onFirstWindowOpen script. If the first-run script sets globals and go to a “dashboard” layout, then PSOS will do the same. Even though it logs in with my username and password, it still is the server running the script. So any functions that return the current time/date, will return Server’s current time and date.

Context is king

FileMaker Server is powerful, but when a PSOS script is called and FMS begins the work, it has no idea where to begin. At the end of the PSOS’s login process, the script is on the onOpen layout, but that’s often not the context in which you want to perform some processing data. So you need to explicitly add a script step in the PSOS script to go to a specific layout. Additionally, it is vital to make sure all globals used in the rest of the script are updated as necessary.

Missing Values

Likewise, any values set in fields with global storage or global variables will be empty. Even if a global field or variable was set in the client file, they do not exist in the PSOS session.

Which records?

Just like the context and global values, the FileMaker Perform Script on Server script doesn’t know which records upon which to work. The script running on the client, the one that called PSOS in the first place may have found some records, but that means nothing to the work done on the server. So in some way, PSOS needs to know which records to find. And you can do this in many ways. Here are just a few:

  • Do the find of records in the PSOS script itself. Let FileMaker Server find the records. But of course, you’ll have to tell the PSOS script which records to find. And that can be done by passing the find criteria in as a parameter of the PSOS script.
  • Do the find in the script performed on the client. Pass the primary keys of the entire found set up to the FileMaker Perform Script on Server script. Include in this script a layout on which is a field. In this field is placed the primary key list. FInally use Go To Related Records to go to the correct context from the starting point of this field.

What edits to make

Once PSOS has the found set, it is vital to tell it what to do with these records, what updates to make.  Again, since the client script probably has that info, the PSOS script step must pass this information up to the server. Along with the find criteria, I’d pass this up to PSOS as a JSON object. We often use fields with global storage as places people can enter find criteria. Those aren’t available in the PSOS, so we have to pass it up. Here’s a sample of what I did while working with my user group colleague.

The first item was the find criteria. The remaining items were used to update the found set of records. Both the find criteria and the update info were generated in the client-run script based on user choices.

Locked Records

Just as a client-run script, if a record is locked, the FileMaker Perform Script on Server script cannot update that record. If we’re in the middle of a loop and the 47th record is locked, it won’t get updated. We have to handle that in some way.

We advocate a transactional approach to handle records that might be locked. If all of them should be processed or none of them, transactions are the way to go.


PSOS cannot be debugged in the normal sense using the Data Viewer and Script Debugger, so instead we have to find all the errors in our code and eliminate those. But we also have to prepare for unexpected events. To the former, as we work on the script, we can choose to run it on the client instead and debug it using the normal tools. We work through the script and make sure that everything works as expected. We also make sure that the script goes to the right context and finds the right records.

Unexpected events happen, and unexpected events could happen in the PSOS script, and that could cause major issues. So we have to be extra diligent in bailing out of the script whenever an error is encountered that would break the rest of the script processing. Here are a few times you’d want to bail out of the PSOS script when an error occurs

Possible Errors to check

  • There are no records in the found set.
  • The PSOS session fails to go to the correct layout
  • A record fails to update (though you may want to handle this differently. Rather than bailing out of the PSOS script, simply log the record that is uneditable).

The bail out process is pretty simple: After setting Error Capture to be On, get the error of the previous step. If it is not 0, then exit the script with that error code as the exit parameter:

Set Error Capture [On]
Perform Find
Set Variable [$json ; JSONSetElement ("" ; "error" ; Get(LastError) ; JSONNumber )]
If $error <> 0
Exit script [ $json]
In the client script, the one that called the PSOS script, use Get(ScriptResult) and see what error took place: JSONGetElement ( $result ; "error").

Wait for it

Finally, the option to Wait for Completion in the FileMaker Perform Script on Server, which is on by default, simply tells the calling script to wait for the PSOS script to finish its work. In most cases, you want this. The script on the server is working, processing a bunch of records. That process needs to finish before the client script can continue. But it is possible to uncheck this option and allow the script to work on its own. There seem to be a smaller number of times when you’d want this, but it is possible.

Perform Script on Server: Use it

FileMaker Perform Script on Server is a powerful tool that offloads complex processes to the server. When used properly and when considered carefully, its use can speed up the processing of data for your users.


We are excited to announce that our FileMaker Addon LedgerLink now supports adding and syncing attachments. This feature is included in LedgerLink v3.1.0.

Here’s a rundown of the features:

  • There’s a portal to store any number of attachments.
  • LedgerLink automatically filters to allow Quickbooks Online supported attachments. Those include
    •  PDF
    • JPEG
    • PNG
    • DOC
    • XLSX
    • CSV
    • TIFF
    • GIF
    • XML
  • Once the files are added to LedgerLink, they can be synced to Quickbooks Online just like any other data.
  • LedgerLink includes the ability to add “Existing Files”. These are attachments stored already in LedgerLink. A quick and simple interface allows you to attach enter of these into the invoice record and thus synced.
  • Each attachment can be previewed. This is done by exporting the file and opening it up.

Check out LedgerLink. Download the demo and give it a try.


If you want rich interactive charts in your FileMaker app, you are going to need to go beyond the built-in FileMaker charts. Luckily, the FileMaker Workplace Innovation Platform has escape hatches you can use to get just about any job done. In this post and video, I am going to show you how to make FileMaker Interactive Charts with the maybe the most powerful escape hatch in the professional Filemaker developer’s toolkit, JavaScript!

Why Not Just Use the Built-In Charts?

The built-in charts that come with FileMaker out of the box are fine.  They work well and look pretty good. But they are static. There is no animation and they don’t respond to clicks. There isn’t any way to drill down into data sets or otherwise explore the visualizations. Also, data visualization goes way beyond whats provided by the built-in charts.  If we need that extra innovative experience in our apps then we reach for the JS.

FileMaker Interactive Charts

We’ll need some JavaScript and a charting library. We’ll use C3 for this demo. The C3 Charting library is a built on top of D3 the most popular data visualization JavaScript library on the planet. It provides a lot of functionality and a lot of customization possibilities. Take a look at this video to see how to set up the library in your custom app

Oh, and download the files here to follow along.

FileMaker C3Charting

The video is about 45 minutes long. Here’s a breakdown of the sections:

  • 00:00–Setup
  • 17:40–Customization
  • 31:33–Handling Clicks
  • 40:41–Dashboard Possibilities

Some notes

Completely customizable

FileMaker Interactive Charting gives us complete control of the chart. Here’s a partial list of elements we can control:

  • The type of chart
  • Displaying two types of charts in the same graph.
  • The labels and their format
  • The x-axis categories, their display format, and the number of ticks.
  • The y-axis placement (left, right, or both)
  • What happens when you click on or hover over a data point.
  • The colors of each line or bar or pie segment
  • Whether or not grid lines are drawn in the graph

It’s incredible what we can do, and it is fairly easy to set up.

Takes some time

FileMaker C3Charting does take some time to set up, but it gets easier the more times you do it. There’s the data structure and the library files code copying. You have to write in the customization you want and so on. There’s a lot to do, but that’s okay. It is worth the time to get the chart exactly how your client wishes it to be.

FileMaker Interactive Charts

Dashboard possibilities

With a Web Viewer and with this charting library, you can set up a dashboard. More than one chart can be visible, each chart having different properties. With this library, a dashboard is easy to generate.

We will revisit this

FileMaker Interactive Charts requires a lot more discussion, so don’t think we are done with this discussion. In a future video, we’ll explore how to use JSON as the data that drives the chart.


The C3Charting JavaScript library is great Pro tool to add to our tool box when we need to go out that escape hatch and get the job done.  In this case, we made some awesome FileMaker Interactive Charts. We’ll continue our study of JavaScript that we began at DevCon. Please join us in the SLACK channel, and we’ll talk about these. And stay tuned to our site for more integration videos.




In the DevCon 2018 training session on JavaScript, we took a look how to integrate various JavaScript libraries into FileMaker. We only got through one, and I’m sure I went pretty fast during the remaining minutes to make sure that I at least completed it. I might have lost a few folks. 🙂

But that’s okay. No DevCon Attendee left behind!

The week after DevCon I began to record videos of how to do the work. My plan was and is to work through each integration and walk through how I’d do the work.

So here’s the first one.

DataTables in FileMaker

Here’s the files for you to try out.


This video is long. It’s 53:00. So I broke it up into a few sections. Check out any of the sections in which you’re interested. (But, it’s good to watch the video in whole).

  • Basic Setup: 0:00
  • CSS Styling: 30:38
  • Functionality (adding the row click): 38:20
  • Table Options: 51:02.

Some Thoughts

It’s a fairly speedy process

I’ve done this enough that I can set up an integration in less than 20 minutes. I usually export all the code from a previous project or a practice file, so that makes things go even faster. And with more practice, you will get even faster. One DevCon attendee reported to me that he thinks it would take him 10-15 minutes to do another integration. The set up I’m advocating is simple. It’s fields and tables. That set up works for now.

Styling can take some time

The hardest part of this is styling it. You have to get down into the nitty-gritty of the CSS and adjust individual items. In the above video, I talk about it a bit, but this will require some more study.

The default library is a good start

DataTables comes complete with a full set of functionality. Once you install it into your custom app and load it with data, you can sort by columns, do filter-as-you-type, and adjust the number of records showing. There’s no additional scripting or buttons or tricks; just use what the (very well tested) library provides.

Alt ways

I’m suggesting one method here. But there are others, and we’ll discuss those in the future.

There’s one more method for using DataTables in FileMaker. For all my talking about using JavaScript in FileMaker, I’ve got a config file that will allow you to set up an integration without knowing any of the underlying JavaScript. Check that out here.


DataTables in FileMaker is one way we can innovate in FileMaker. We can provide a professional set of functionality to our clients. This functionality may not be needed for every list or portal. However, if the client asks that related records are sortable and searchable, we can turn to this library for complete help.

We’ll continue our study of JavaScript. Please join us in the SLACK channel, and we’ll talk about these. And stay tuned to our site for more integration videos.

Download the source, start file and finished file here.

Training Day at DevCon 2018 finally arrived, and I was ready. After fretting over my ‘lesson plan‘ for so long, I was ready to do some FileMaker DevCon JavaScript training, for FileMaker developers. So I left the breakfast room and entered my classroom. I was hoping to get some moments of calm before we started. To clear my head, to focus on the material at hand.

I walked in the room, and there were like 20 folks there. “Woo,” I thought.  I got them started on some ‘morning work’ to prepare for the time.

A few minutes later, there were over 60 people in the room., still barely 45 minutes before the 8:30 AM start time. I handed out more USBs.

By 8:30 am, the start time, folks were ready to learn JavaScript. A lot of them.

The JavaScript worm

Slowly but surely, JavaScript is becoming more present in FileMaker developers’ minds. The training session brought in over 150 people that think about JavaScript. These folks are interested in the power of JavaScript, in the fact that it is easy to learn and use. We are intrigued by the possibility that we can develop interactive charts or include a whole set of functionality in just a few minutes (maybe an hour at the most). We recognize part of making our custom apps innovative for the workplace is to use all the professional tools available, including JavaScript.

There’s a season for everything

I’m not the first to advocate for JavaScript in FileMaker. Many folks have come before me and have said the same thing. I rest on their shoulders. But now, it seems, is the good time to really explore what we can do with JavaScript (almost anything) in FileMaker. We get a glimpse at what we can do with the language. The time is right; let’s keep moving forward.

Many of the people & compaines who’ve contributed to my knowledge of JavaScript and the Web Viewer.

In the session

Focusing on pure JavaScript, we studied how to work with the Web Viewer.

For a very quick three hours, we took a look at JavaScript in the form of pure JavaScript and in the form of JavaScript libraries.

JavaScript, pure

First, we did a very brief study of some JavaScript concepts. I believe we all should know a little bit of the language so that when we want to do something in a library or in a blank web viewer, we have the knowledge to achieve it. So we spent time on pure JS, writing functions that added text to the web viewer or changed the color of a background. We built buttons in the web viewer and attached events to them. We learned a bit about variables and scope and functions.

JavaScript Integrations

After the break, we turned to JavaScript libraries, the fun part. Together we walked through how I have set up working with libraries to integrate into our custom apps using FileMaker data. We started with a chart and set it up, talking about that set up and how to customize the chart. The concepts we practiced in the first half helped us out here.

Along the way, I got to work with individuals and help them through very common mistakes (a missing comma or semi-colon). I also spoke about JavaScript concepts such as variables and scope and functions.

It was quite unfortunate that we didn’t have a full day to do this work. I wanted to spend more time on pure JavaScript and on how to integrate libraries. We completed 9 out of the 25 exercises, and only got to review one out of the eight integrations. But not all is lost. See below for more info on a plan.

I encouraged folks to sign up for the FM/JS SLACK group we started up a while ago. And many folks did. That’s one of the ways we’ll stay in constant contact throughout the next year.

Beyond the session

People left the session excited about using JavaScript. Many people approached me saying they see it as much more accessible now that we went through it. They were inspired to begin to use what we did in their own apps. That’s very cool. My goal has always been to excite FileMaker developers about JavaScript.

During the week of DevCon, at least two people continued the training session by working on an integration. Phillip Jaffe worked with the DataTables integration, and Logan Cornelius worked with the C3 Charting library. Through text messages or on SLACK or in person, I worked together with them to get their libraries integrated and to talk about the nuances of the library. We met at the Geist Interactive booth or in the hallway to get it worked out. Both attendees got their work done by the second day of the conference. Logan reported it took him about an hour to get the charting library working with data from his app.The rest of the week he tinkered with it, changing colors, adding options. 

I could tell he was excited about the work he did. And so was I.

Continuing the session

Lest anyone think they’ve heard the last of the session, we have a lot in store in the upcoming year. We want to keep this conversation going and inspiration hi, so we will do something with JavaScript every month leading up to DevCon 2019!. Here’s a list of what we’ll do and how you can participate.

  • On the FM/JS SLACK group, we’ll talk JavaScript and how we’re using it in our apps. It’ll be a great casual conversation. Please join and get in on the conversation.
  • The JavaScript training materials are found here. Download those and try them out.
  • I’ll do videos for each of the exercises in my JSPlayground file, and will set them up on a JavaScript-dedicated webpage.
  • I will do a ‘let’s integrate’ video for each of the integrations found in my session files. You can watch and listen as I work on one of these at a time.
  • As logistics allows, I’ll talk JavaScript at user groups throughout the community. Todd and I will be at the west coast user groups (Portland, Seattle, FMDIG, FMDisc, and San Diego) in October to talk JavaScript and other professional tools.
  • Occasionally we’ll do webinars on JavaScript and JS integrations. We’ll alert you in plenty of time so you can plan to attend.
  • And of course, I’ll suggest using JavaScript in the forums. I’ll be the first to admit not everything is a hammer (not everything needs JavaScript) but where it is a viable option, I’ll suggest and provide a sample file.

Join us for any of these events. We’ll take the next year to learn JavaScript and how it can be used in our custom apps.

Filemaker Devcon JavaScript Training

The future of FileMaker and JavaScript is bright. We will continue to promote its use and inspire folks, and I hope to work with others in the community to do the same. JavaScript is one of the many professional tools FileMaker developers can use to innovate.


In less than a week (as of Monday, July 30), I will work with FileMaker developers to learn, or get started learning JavaScript. I can’t wait. While I’m nervous about it, I’m also pumped that we get to talk the power of JavaScript and the power of the web viewer. It’s been my life’s goal (for the past 4 or so years) to get FileMaker folks excited about using JavaScript. We get to take another step in that direction. JavaScript is easy, it is powerful, and it is part of native FileMaker.

If you’ve not yet registered up for the training day (an additional cost), I encourage you to do so. I know it’s an investment. So to make sure your return will be adequate, I’ve described in pretty minute detail what we will do during the morning (there are other great sessions in the afternoon). You can check out the outline here. And you can review this video.


The Highlights

On our minds

As we wrap our brains around JavaScript, we’ll keep in mind two questions:

    1. How does our current understanding of FileMaker help us learn JavaScript?
    2. What are the benefits to using JavaScript in our FileMaker development?

In education, these are called “Essential Questions”. These are vital mainly to our adoption of JavaScript as a viable tool in our FileMaker development, and they keep us grounded. As cool and powerful as JS is, we need to remained focused on our client’s data and custom app and needs.


We will spend most of the time in the session:

  • Working with pure JavaScript. We’ll write little functions that accomplish something for data presentation in FileMaker or data manipulation.
  • Exploring how to set up using JavaScript in any environment, for any custom app.
  • Implementing and customizing current JavaScript libraries out there for our use.

I’ve got quite a few files for us to work with. Here’s a few screenshots.

We will spend a lot of our time in here. writing functions that display our data in interesting ways.

We will spend a lot of our time in here. writing functions that display our data in interesting ways.

This file is a reference for what is known about the web viewer object

An example integration we’ll implement.

Join the JavaScript revolution

I encourage you to sign up for this training session. The more FileMaker developers that know and use JavaScript, the more the movement grows and the more awesome custom apps get delivered to clients.

Join me August 6, 2018 at 8:30 a.m. at DevCon 2018 to begin the JavaScript journey.


Introducing FileMaker Kanban. This tool organizes data such as tasks in a visual way into lanes and cards. It is familiar for users and flexible for developers. The tool provides a full suite of data-management functionality. A FileMaker user can organize the tasks into different lanes, reorder the lanes, edit the data, and add new cards to the board and to FileMaker.

Familiar for the User

Kanban provides a rich and familiar interface for all FileMaker users.

They can clearly see the organization of the tasks as cards on lanes. Further, any user can move the cards or lanes, repositioning them on the board and saving the position back in FileMaker. Cards can be added to the board, data can be edited. There’s a lot of functionality possible.

Flexible for Developers

FileMaker Kanban is just that. It consists of a layout, a web viewer, and some scripts. That’s it.

These scripts allow the developer to make many changes including:

  • Change the color of the board background
  • Remove dragging functionality
  • Remove editing functionality
  • Use data to change the color of a card background

And much more. Find out all the possible customizations.

The scripts that run from the FileMaker Kanban board can be easily disabled or adapted for any custom app.

And the data that generates the board is a JSON object, which can be constructed in any number of ways using just FileMaker. The example uses tables and fields and records, but that’s only one way.

Give FileMaker Kanban a try

Read more about Kanban and download the demo and see how Kanban is easy to use, to implement, and to customize. The demo is fully-featured, though it does limit the data to three lanes, and shows an additional lane with relevant Geist Interactive blog posts.


We love Kanban, and we are excited to use it in our daily work. See if it works for you.