One day, after exploring Sigma’s app builder features for about a month, I had a eureka moment. I came up to my coworker Josias, “I am going to try to make a game in Sigma.” I could not think of a more perfect way to test the tool.  

When I found a deck of cards dataset in our company Snowflake Sandbox, I knew I had to try to make a Texas Hold’em simulator. By leveraging Input tables, dynamic text and conditional action sequences, my idea quickly transformed into a functional simulation.

Call Stored Procedure 

The first step in any card game is dealing the cards. For our poker simulator, that means randomly generating a set of cards from a 52-card deck without replacement. While Sigma doesn’t have a native function for this, we can leverage the power of a stored procedure from the data warehouse. I wrote a simple SQL procedure to handle the randomization and made sure it had the correct permissions to be accessed from Sigma. Then I used the “Call Stored Procedure” action to simulate dealing all the cards necessary for the game.  

It is important to make sure the stored procedure returns as an array so the result can be put into a single cell. 

Now that we have an array with randomly generated card IDs (in this case just numbers 1 – 52), we can start building the rest of the game. If you are confused as to how this works or want to learn more about how to use Sigma actions, check out my guide.  

Clean the Array

Before we can actually use the information generated from the stored procedure, we need to parse the array and convert it into a tabular format.  

I used a combination of SplitPart (which functions the same as Split in Tableau) and RowNumber to split the string and pivot it automatically. The Replace() functions help cleans up extraneous text from the array.  

Leverage Dynamic Text and Image URLS 

Based on the cards drawn from the stored procedure and a data table containing information on all 52 cards we can create a table outlining the information on the cards in play.  

With our cards now in a usable table format, it’s time to bring the game to life visually. I started by finding some open-source poker card images hosted on public URLs. This was a critical step, as one of Sigma’s coolest features is the ability to integrate dynamic text directly into an image object. This lets you assign a formula to the image itself, allowing it to change dynamically based on the data. 

Now we can have a single image element display either the back of a card or a specific card from the deck. This is dynamic based on the player or phase of the game. Now we have the ability to reveal cards based on the current phase of the game and also to “deal” new cards each time we refresh the results from the stored procedure.  

All the Controls 

As BI practitioners, we usually work with traditional “tall” data tables; but in Sigma, I often find myself gravitating towards using a few “wide” input tables. I use these as dynamic reference tables, similar to how I use controls, but with a little more flexibility. I created a table to track chip counts for each player and the pot using this technique.  

By configuring this as a table, I can easily visualize how many chips each player and the pot have based on the data in this element, which would not be possible if this was a control and would be a hassle if this was a vertical table.   

When using “wide” tables like this, I’ve learned a best practice: assign a unique ID column to the single row of these input tables. Then, create a control that holds this ID. This method makes writing and managing action formulas much more consistent and reliable. 

On the other hand, to manage the flow of the game, I created a segmented control. Now we can model and reference the active phase of the game. Additionally, but using the “Set Control” action we can easily update the currently active phase.  

Conditional Action Sequences 

Conditional action sequences are easily one of Sigma’s most powerful features, and they were the key to making this poker simulation effective. I used a series of conditional action sequences which manage updating the status of the chips table based on who is betting. I used a similar system to update the chips based on who won. The core logic of the game would not be functional without conditional action sequences. Notice how the top bar indicates a custom formula for the condition.  

Using Customizable Page Visibility to Keep Hands Hidden 

Of course, a poker game isn’t a game if everyone can see the cards! To prevent players from cheating, I used Sigma’s custom page visibility feature. I created separate, private pages for each player and configured the visibility to only show a player’s hand on their designated page. In this demo, I made a private page for Player 2 (my friend, Josias) where he can secretly peek at his cards without anyone else seeing them. 

Potential for More 

This poker simulator is simply a proof of concept to showcase some of the insane capabilities Sigma allows. As such, I did not add every possible feature one would expect to fully automate the poker playing process. That being said, here are some additional features which Sigma would certainly support:  

Betting Phases, Check and Call 

It would be relatively easy to add more phases for each players bets and prompt them to complete a modal before moving to the next player. 

Folding 

This would be pretty easy to implement but take a bit of work to add player fold indicator controls and then change which cards show based on if a player has folded etc.  

Automatically Determining the Winner 

This one would be more complicated. Involving a folding indicator and a series of lookup tables. Also, technically, ties are possible in poker and my proof of concept does not support them. 

Post-Game Report 

If we kept track of the changes to each player’s chip pool instead of just or in addition to updating the main row, we could visualize how the chip distribution changed throughout the rounds of the game.  

Honestly, it is difficult to think of features that Sigma would not be able to handle.  

I was so impressed by how quickly this came together, how effective and good it looked. Sigma is a powerful tool if you know how to use it. What features do you think would make this app even cooler? What project should we make in Sigma next?  

The post How I Made Poker in Sigma appeared first on InterWorks.

“Don’t Panic”

The words printed on the cover of Douglas Adams’s Hitchhikers Guide to the Galaxy ring true in the case of disasters such as this. Luckily, thanks to Sigma’s API, restoring a lost connection does not need to be such a headache.

I am going to take you through the steps to restore a lost connection in case a “friend” has accidentally deleted one. All the steps detailed below require admin access in Sigma but so does deleting a connection.

Getting Your Credentials

The first thing you’ll need to start helping your “friend” fix their mistake is your client ID and client secret for Sigma API, as well as the correct request endpoint depending on your host.

These are all found under the Developer access UI in the administrative view.

• Click on the profile action in the top right
• Select administration (you will need admin privileges for this of course):

• You’ll find Developer access on the bottom left with a key icon:

I recommend getting out your handy dandy notepad, as you’ll want a few things readily available for copying and pasting.

The first thing you need to grab is the API base URL, this is the endpoint you’ll be requesting from the API and it is automatically generated here based on your cloud provider:

Next, you’ll need a Client ID and Client Secret.

• Click the “Create New” button in the top right corner:

• Select REST API, complete name and description as you please, and assign yourself as the owner.
• Click Create:

Once you create the client credentials, a box will pop up with the newly generated Client ID and Client Secret. Copy them both and record them in a secure location (your handy dandy notebook, perhaps).

Okay, now that we have our credentials, we can start looking for our lost connection.

Finding the Lost Connection

Sigma’s API has information on all connections that your organization has made (archived or otherwise). The key piece of information we are looking for from the lost connection is the connectionId.

• First go to Sigma’s List Connections page.
• Make sure the URL matches the one we copied earlier:

• Enter your client credentials and authorize the token. This will generate a Bearer. I recommend copying this and saving it as well:

• Under QUERY PARAMS, find includeArchived and set it to true. This will allow your lost connection to come through in the request, SO DON’T SKIP IT!

• Click the “Try It!” button underneath the automatically generated code:

You should be greeted with a list of all the connections associated with your organization, active or otherwise. If not, go back to the top of the page and make sure all of your information is correct:

You are looking for the “connectionId” of the deleted connection. There is a chance that the “name” of the connection is somewhat different from what you may remember, so look for clues in the response such as “lastActiveAt” and “isArchived.”

You should also record the name just to be safe, but you probably already know the name because it has been popping up on all sorts of error messages recently.

Now that we have the connectionId of the lost connection we can (hopefully) update that connection to restore it.

Updating the Connection Via API

No more messing around; we are almost there!

• Go to Sigma’s Update Connections page.
• You may have to enter your credentials again or re-authorize your token.
• Start filling out Params. The most important ones are:
  • connectionID (we got this in the last step)
  • details. Here, you will need to fill out the details of our connection. This should be pretty similar to the information you use when creating a connection in Sigma
  • name (ideally this should match the original name of the connection)
  • Set “restore” to “true.” This is SUPER IMPORTANT because it is what will restore the connection:

Including more details is generally better here.

You may also find issues where you are getting “Unable to connect to host” messages. This can be caused by formatting issues relating to authentication strings. This happened to my “friend” when copying and pasting the connection key — the line escapes “\n” were not being imported into the website correctly. If this happens to you (or your friend), I recommend copying the request code from the website in the language of your choice and pasting it into your coding environment, then you can control the formatting of your authentication strings much easier.

You will know you have succeeded when you get a response that looks very similar to the one which was returned when we requested the connectionId in the last step: A JSON response of updated connection information.

Clean Up

Now you should see the lost connection returned home in your Sigma environment. You may still see some errors in your workbooks but remember: Don’t Panic. It may take some time and refreshing for everything to return to order. You may also find some straggler workbooks that still have errors in the published version but are fine in edit mode. Simply republish the workbook and the errors should resolve.

Prevention

The best way to deal with these kinds of mistakes is to prevent them in the first place. Follow industry best practices and use test environments before publishing to production. When making changes to a connection, create a new connection instead to ensure the original (as well as its dependencies) are not compromised. After ensuring this new connection is working as expected, you can edit the original/production connection to match the new functionality. Limit the number of users in your organization with admin privileges to only those who need them.

Additionally, you can enable Sigma’s Audit Logs for your organization to easily keep track of changes made to the environment. For example, you can find the connectionID of an archived connection in the audit logs. Look for something like this:

Chin up

These things happen. As long as you don’t panic, you will be fine! Did this blog help you get out of a sticky situation or find yourself in another one? InterWorks is here to help!

The post Help! One of Our Sigma Connections Was Accidentally Deleted (Asking for a Friend) appeared first on InterWorks.

The post Creating a Sigma App to Track Company Flights and Carbon Emissions  appeared first on InterWorks.

When I first started working with Sigma I was not sure if the tool would be able to create dashboards with the same high fidelity look as their competitors, such as Tableau. The grid layout’s ease of use and approachability for newcomers was a plus, but I had reservations about limitations around graphics and formatting. However, after spending a lot of time with the tool, I realized there’s a lot more flexibility when it comes to visual design than at first it may appear, with the power of the grid layout and containers developers can achieve the polished, pixel perfect look that stakeholders love to see.

Setting up For Success with Workbook Settings

The Journey to successful spacing in Sigma begins with workbook settings. I prefer to set Spacing to “Small” for maximum flexibility. Spacing determines how far apart your elements will sit from each other the “Small” setting has elements as close to each other as possible. However, Element gap is automatically enabled for the entire workbook. Although element gap cannot be turned off for the entire workbook, developers still have full control over which elements can be adjacent to each other. Additionally, if you are worried about pixel perfect views you can also turn on “Always show grid” to keep an eye on how your elements are interacting with the grid:

Additionally, I recommend defining your workbook Max Width (px) early in the development process to prevent having to adjust your elements many times. No matter what size you set the max width of the workbook there will always be 24 columns in the grid.

Page Overview

In case you didn’t know, in the bottom left corner of the screen, there is a little stacked lines icon. This is the page overview which shows all the elements in a page, and how they are related to each other:

From this menu you can expand or contract elements within a container and select elements to highlight them on the page. For those familiar with Tableau this is essentially your item hierarchy. When working on design in a workbook I find myself referring to the Page overview often to understand why elements are behaving in any given way.

Understanding Container Settings and How to Use Them

Now we have set up our workbook and understand how to track the hierarchy of item management, we are ready to start building our data app. Although it is tempting to start throwing cool elements and visualizations up on the screen, the first thing you should put down is a container. Outside of containers elements will always have a gap between each other. However, in containers element gap is a setting which can be switched on and off. So, by using a container for the entire page, we gain maximum flexibility in our layout. Additionally, containers do not necessarily take up space, so we are not losing out on valuable digital real estate.

Now let’s dive into the settings for containers, what they do and how to use them.

First, under the properties pane we have Layout Grid Density. This setting controls the number of grid columns in said container.

• Low: 6 Columns
• Medium: 12 Columns
• High: 24 Columns

This is true regardless of the container’s width. Meaning if you want to jam in more elements, you can have multiple high-density containers adjacent to each other:

Here is an example of how three high density containers next to each other can look. Notice how the columns outside of the container are wider than those inside the container:

I recommend setting this to “High” on all containers as this will give you the most flexibility on element placement.

Next, we have the format settings:

Spacing works just like the workbook setting but on a container level. Again, I prefer to set this to “Small” for most containers.

Padding essentially works like internal padding in Tableau, so when this is turned on in a container it prevents elements within that container from touching the border of the container.

Element gap is something we have already touched on. This tool controls whether elements within the container will touch or have some space between them.

Element Padding

Just like there is a setting for padding in elements, there is such a setting for many element types. It works in the same way essentially as internal padding, adding space in between the content of the element and its border:

Hidden Tabbed Containers

I have one last trick for you that can really make your data apps look clean and professional: Hidden tabbed containers. The secret is that tabbed containers have an option where you can turn the tab bar off:

This allows you to cycle through different elements in the same space with ease. For example, I have this map in my data app:

What is displayed on the map is changed by the buttons on top. However, there is no way to dynamically change what a button looks like when it is selected in Sigma. However, by Duplicating the buttons and putting the copies into separate tabs we can create a tab for each possible selection. Then we can add the select tab action to the buttons to have them switch tabs based on which button was pushed:

And finally, we can hide the tab headers to give the illusion of floating buttons which change color based on which is currently selected (in reality there are nine buttons in three tabs).

Wrapping Up

By combining all these settings and leveraging the grid system, we can quickly create apps which have elements that line up seamlessly. Pixel perfect pages are possible in Sigma because of the grid system not despite it.

Here is a standard page of a data app before implementing pixel perfect techniques:

And here is the same view after using our techniques to clean it up:

Notice how the Picture in the top right seamlessly transitions into the dashboard, but the buttons on the left still have padding. We achieved this by layering containers with different settings.

Now our app looks clean and pixel perfect. What do you want to learn about next in Sigma?

The post Pixel Perfect Pages in Sigma appeared first on InterWorks.

Although summer is almost over, it is never too late to start to work on your beach body. My friends challenged me to do a sit-up every day for 100 days while increasing the number of sit-ups each day by one, so on the last day, we do 100 sit ups.  

Of course, I thought it would be fascinating to track this progress, and Sigma seemed to be the perfect place to do it.  

Although Sigma lacks some of the most customizable features of other BI platforms like Tableau, it still boasts an impressive suite of visualization options. In this blog, we will highlight how to build a simple line chart, and turn it into an application by improving formatting and leveraging Sigma’s writeback capabilities. Additionally, we will be automating recurring subscriptions to the data.  

That said, let’s break this into three distinct parts: we’ll start with something good, get a little better and finally find out how to make this the best viz we can.

Good

Step One: Building the Table  

We will start from scratch here with an empty input table: 

(For more information on input tables, check out my previous guide). If you have data in mind, you can of course connect that way. 

Let’s leave the starting text column for now (we can reference important dates here later).  

Next, we are going to add some calculations to fill out our table. Let’s start with the number of Sit-ups to do:  

We create a new column and select calculation. The granularity of our table will be daily sit-ups, and they increase by one each day, so a simple RowNumber() calculation will work to generate our sequence of increasing values. Sigma starts us with three rows, but we will go ahead and click the plus underneath the row number to get us to 100 rows. (You can also just hit enter on the last row to achieve this):

Great! Now that we have the number of sit-ups we need to do each day. All we need to make a chart is the day on which we need to do them.

We will start the day I am writing this blog, but you can start whenever you are ready for the challenge. We will use another calculation column and use a dateadd() function to create a list of 100 dates. (In the function, use the day before the day you want the chart to start):

 And just like that, we are ready to create our basic chart. It only takes two fields, after all.  

Step 2: Line Chart 

Let’s go to the elements pop out on the bottom of the screen in Edit view and select a line chart from charts. Line charts are great for viewing data over time:  

We then choose the input table we created as our data source: 

 Make the X axis the Date field and put “Number of Sit-ups” on the Y axis:

And Bam! We got a line chart, people: 

But this chart offers limited analytical insight. We already knew we would be doing 50 sit-ups on day 50. But how many total sit ups will we have done by day 50? What percentage of the total number of sit ups will we have completed by the end of September? 

Step 3: Adding a Second Line 

 Let’s add some more calculations. Let’s start with a total number of sit-ups in a new calculation column. We will use Sigma’s CumulativeSum() function to track the running total of sit-ups over time. This lets the viewer gauge overall progress rather than just looking at individual daily values. While we are at it, let’s grab the percentage of total sit ups. The Rollup function is our friend here as it allows us to find the max of the entire column instead of just a single row: 

 Now we can add percentage of total completed to the chart:  

Well, that doesn’t look great. There are a couple of potential solutions. Either we could change the number of sit-ups to a percentage, or we could make this a dual axis chart. Let’s try dual axis.  

Select “percentage” in the properties pane and follow the menus to change the axis from left to right:  

By using a dual axis chart, we enable the user to view absolute daily values alongside progress toward our final goal which is crucial for spotting trends and pacing. Now we have a basic line chart that shows the relationship between two different measurements of our progress through the sit-up challenge:  

 This chart is good, but it could be better.  

Better 

Step 4: Formatting 

Now this basic chart is functional, but it still is plain. The titles are too long, and the formatting is inconsistent. Let’s start by cleaning up the titles and legends. It’s best to keep titles simple yet communicative:   

 Cool! Now let’s format the dates and percentages to make them more understandable. We can do this directly in the properties pane:  

Clearly legible formats allow your user to focus on the insights the visualization provides rather than having to decipher the meaning of fields and numbers. Now we have something that looks a little more professional, but there is more we can do. 

Let’s take this to the next level and add a couple of features to bring even more insight into this viz. It would be great to see the total number of sit-ups which were completed on any given day. Let’s add this metric to the tooltip! 

Simply drag the metric into the tooltip pane and give it a reasonable name:  

 We can also add sit-ups remaining by adding another calculation column and then adding it into the tooltip as well.  

Now that’s some decent information. Interactive tooltips provide just-in-time details, keeping the chart clean while enabling deeper exploration. 

Now, let’s look at the chart itself. The colors don’t pop as much as I would want, so let’s start by making the lines a little thicker. We go to the format pane and under line style we have a number of formatting options:  

In the formatting pane, we can also add a reference line to help us track how far along the chart we currently are. Under “Reference” marks, we set a line on the x-axis and with a custom formula equal to today:  

Here is what this will look like 10 days into the challenge: 

Let’s add some more personality to this. Personally, I love a dark theme. We can change the workbook settings to dark theme, then customize our chart colors:  

Green and purple are my favorite colors, and they have decent contrast: 

Let’s format the axis and legend text to make them pop from the dark background: 

Now that’s a good-looking chart. Additionally, with the lines made bolder and theme adjusted to a dark background with contrasting colors, the chart the chart pops out making insights more easily accessible. This is definitely better than the good version, but there is still more we can do to make it the best chart we can. 

Best: 

So far, we have leveraged some of Sigma’s visualization formatting options and input tables to make a pretty neat line chart, but we have not yet leveraged Sigma’s coolest features. What if instead of the reference line updating automatically each day, we make it so the user needs to check off that they have completed the sit-ups for the day? By utilizing Sigma’s action sequences and input tables, we can track our progress against our goal.  

Let’s add a text column and name it “Completed?” Then we can type “False,” or whatever you prefer, and double click the fill handle to fill the column with rows saying “False.” Additionally Create an ID column for the table:  

 Next, let’s make a button. Head back to the elements section at the bottom of the screen:

 Let’s call the button “Log Today’s Progress” for now. We are also going to make to hold a value for our action sequence. Name it “Helper-Control” so it is easy to find:  

Next, click on the “+” button on the actions pane. We are going to create an action sequence:

First, we are going to set the Helper control to be the ID of the first row in the table where “Completed?” is “False.” The lookup() function is the way to go here:

Next, we will update the row to be true based on the ID stored in the helper control:  

Now, we can add a reference band to show our actual progress. We will use another look up function to make the end of the band follow our progress. We’ll set the start of the band a constant value set to the first day of the challenge:  

Cool!

Now, let’s use Sigma’s dynamic text feature to customize our button even further. To use dynamic text simply type “=” and then the formula you would like to use in the dynamic text:  

Great! Now for the finishing touches, let’s put our visualization and button in a container so people know they go together:  

We also moved the legend to the top of the line chart and gave the container a dark purple color to help our viz stand out. I bet you can figure those ones out at this point:  

Perfect! This is just what I want to see, but I want to be reminded of this visualization and button every day so I can make sure to do my exercise and advance my progress. While this is a simple way to set up progress tracking, there are a ton of ways to make this even more interactive (keep an eye out for another blog from yours truly). 

We want to see the whole container in the export as a quick view as well as a link to the workbook so we can log our progress. You will have to publish any changes to your workbook before scheduling the export:  

Feel free to customize the message, sending frequency and times as you wish:  

And just like that, we have gone from a concept of a daily sit-up challenge to a mini data app chock full of insights as well as automatic daily reporting in a matter of minute. What began as a simple visualization evolved into an interactive, user-friendly performance tracker which combines static insights with real-time updates and scheduled visibility. Along the way, we explored chart formatting, advanced calculations and Sigma’s innovative action sequences. And best of all… It works! I am currently on day 38 of this challenge and my abs are really starting to hurt. Wish me luck!  

Sigma offers many more formatting options than the ones covered in this blog, so I encourage you to go out and look for more. Sigma is so much fun to work with. And if you ever need any help with your Sigma projects, let us know and see what we can do to help! 

The post Improving Sigma Line Chart Over Time appeared first on InterWorks.

What are Sigma Actions? 

Imagine enabling users to instantly filter a dashboard to just their regional sales, then automatically opening a detailed breakdown page with a single click. Or picture giving analysts the ability to launch a stored procedure that forecasts next quarter’s revenue, or surface AI-driven insights directly inside your analytics platform, without ever switching tools.

This is where Sigma Computing, the cloud-native BI platform comes in. Sigma provides a suite of actions which can be leveraged to automate workflows and empower developers to create sophisticated data apps with ease. For users sigma action sequences streamline complex tasks into smooth, straightforward workflows. Along with input tables (covered in this blog post), actions are one of the key tools Sigma offers which allow developers to construct apps out of their data.  

Digging in 

There’s a lot to go over here — certainly more than one blog’s worth (we won’t go in depth on cover context menus or plugins here). But here, we will cover what options Sigma provides as well as some general tips and tricks for getting the most out of action sequences.   

Action sequences 

Action sequences are groups of actions that execute in sequence once triggered. Here’s a quick look at a how to create an action sequence in Sigma. 

In order to create or edit actions the user must be in Edit mode.  

1. Select an element (provided you have the right user permissions) while in production view.  
2. Navigate to the action pane. 
3. There will already be an empty action sequence in place. Simply click the “+” in the action sequence to add actions, and begin creating your data app. 

You can also add additional action sequences to the same element by clicking on the “+” near the top of the pane next to “ACTION SEQUENCES” like you can see here:  

Action sequences execute sequentially. Usually, this means each action fully executes before the next begins. However, in some cases, individual actions may be asynchronous. For example, in the case of an action sequence containing the Trigger plugin action, the subsequent action may not wait for the completion of the trigger plugin action before executing. (If you are interested in learning more about when and why sequential execution may not take place, please take a look at Sigma’s Documentation.)

One of my favorite features of Sigma action sequences is that using menus you can duplicate, copy and paste individual actions or even entire sequences, rename and delete actions. These features are especially handy when stacking conditional action sequences which we will cover later. 

Action Sequence Triggers 

There are currently a few triggers for actions sequences supported in Sigma. “On selection” meaning when the user selects the element. “Cell context menu” meaning the action is triggered upon the selection of a particular option set up in a cell context menu. The “on change” trigger occurs when a control value changes. For buttons and images, there is “on click” which is similar to “on select” but does not create a selection action variable. There are also a few action variables specific to modals that function effectively the same as “on click.” 

Additionally, when the element is a table, another option will appear below “On Select,” allowing the user to designate which columns selection will trigger the action sequence.   

Now that you understand how to create action sequences, we will break down what actions are currently available in Sigma and what they do. 

Available Actions 

We will take a quick glance at all the actions Sigma currently offers at the time of writing and their functions. Generally, actions are straightforward to implement, so I’ll keep explanations brief to focus on how to get the most out of actions at a higher level.  

Navigation 

These actions are used to navigate the user both in and out of the Sigma environment.  

Open Link 

Opens a URL in the web browser. You can use dynamic values here to reference a control or column if you want the URL to be dynamic. Additionally, there are options to control whether the URL will open in the same window, a different window or the parent window (for embedding). 

Open Sigma Doc 

Like Open Link, Open Sigma Doc allows the user to navigate outside of the current workbook, but in this case, the user is navigated to another workbook in the Sigma environment. Additionally, this action has the same window options as Open Link.  

Navigate in this workbook 

Likely, this is the navigation action which will be used most often. It allows users to navigate between pages of the same workbook, or even within the same page. Developers can decide if the action navigates the user to the top of a page or to a specific element within a page.  

Select Tab 

This action changes the tab of tabbed container to the next tab, the previous tab or a specific tab. This action is useful especially when you do not want to use the default tab headers. 

Download and Export                    

Exports the workbook, a specific page or a specific element from the workbook. This can be a download, email, Slack, Teams, SharePoint, webhook or cloud storage. Not all integrations are enabled by default. Those which are not enabled by default must be configured by an admin. Exports can be formatted as PDF, PNG, Excel files or .csv, depending on the type of element being exported and the destination of the export. Additionally, for PDFs, you can specify formatting options. For Excel exports, you can choose whether to include metadata.  

Controls 

These actions allow the user to interact with control elements.  

Set Control Value 

Sets a specified control to either a column (based on a selection), another control or a custom formula.   

Clear Control 

Clears the value of a specific control or all controls on a specific page. It is often the best practice to use this action at the end of an action sequence which closes a modal, so all controls on the modal are cleared so they can be refilled the next time it is opened.  

Elements 

These powerful actions can directly modify elements within the workbook and which variables are used within them.  

Modify Element 

When choosing this action, the developer is prompted to select a target element, then how to modify the element from the following options: 

• Show columns: Select a number of columns to reveal from the element with an option to hide any unselected columns. 
• Hide columns: The same but in reverse.  
• Move Columns: Assign columns to a particular property of a visualization such as tooltip. 
• Swap Columns: Replaces a column in a property of a visualization with a different column.  

These actions are especially useful to get around some of Sigma’s visualization limitations such as not being able to stack hidden charts on top of each other. Instead, Sigma empowers the user to completely restructure an element through Element actions.  

Refresh Element 

Refreshes a particular element including any calculations or data connections.  

Modals 

These simple actions control modals. Modals are elements which appear on top of an app page in Sigma. Usually, they contain interactive elements such as controls for users to fill out like a form, but they can take many other forms.  

Above: The “Request New Flight” Modal appears over the top of the app page.  

Open Modal 

Opens a specified modal. 

Close Modal 

Closes the current modal.  

Input Tables 

These actions allow for the modification of input tables through element interaction and actions. Some input table actions may be limited by user permissions and warehouse configurations. Some input table actions also generate action variables. 

Insert Row 

This action inserts a row into a particular input table. The input table must be able to be modified vertically (See my guide to input tables in Sigma). Each column can be specified to insert as a static value, control or formula.  

Update Row 

Update row works similarly to insert row, but the key difference is with the update row action the ID of the row must be specified. Best practice here is to set a control to an ID and then reference that control. 

Delete Row 

Delete Row works just like update row. However, the only input here is the ID of the row to be deleted.  

A note on inserting and deleting rows: If you plan to insert rows or delete a row then use some other Input Table action in the same action sequence, you may run into surprising errors. This is one of the reasons why using controls is good practice. 

Advanced 

These are the more advanced actions available in Sigma at the moment. All of these require some sort of work outside of Sigma’s environment. They need to be enabled by admins or developed outside of sigma in some way. Additionally, plugins specifically can be set up to be targets or triggers for actions. 

Call Stored Procedure 

Calls a stored procedure from the data warehouse. The called procedure must return a scalar value meaning a result which can be stored in a single cell. This action also creates an action variable that can be used in formulas in the action sequence. Not every data warehouse provider supports the called stored procedure action. As of writing, only Snowflake, PostgreSQL, BigQuery and Redshift are supported. See Sigma’s documentation on limitations here.   

Generate iframe event (for embedding) 

This action generates event keys and values named by the developer. The Key value can be set as a particular data type or a formula. These outbound iframe events can then be sent to a plugin which is configured to respond to them in some way. Read the sigma documentation here. 

Trigger Plugins 

Plugins are elements whose code is hosted outside of the Sigma environment. This action triggers a specific plugin effect. See Sigma documentation here. 

Advanced Techniques 

Now that we have covered the fundamentals of each action type in Sigma, we will cover some tips and tricks to get the most out of these actions to create a killer data app.  

Using Controls 

Controls allow developers to easily create dynamic references for calculations. This is especially helpful when dealing with complicated action sequences. Often, best practice, especially when updating and deleting rows via input table actions, is to set a control to the ID of the target row then delete or update based on the control value. This helps to break up complicated actions and calcs to make them both more understandable and executable.  

For example, when setting up a flow for updating an approval column: First, create an action which updates a control to the ID column of the table with the approval data. Next, you can fill out a modal with the controls you want your user to interact with, and when you create an action sequence to update the row, you can have it reference the ID you set earlier. 

Above: Here we set a control (hidden on another page) to match the ID of the selected row. The rest of the action sequence prefills the modal which will open with information from the selected row.  

Above: Now, in the modal we update the row which ID matches that of the control we updated when opening the modal. 

This concept applies beyond input tables as well. If you find yourself trying to put too many steps into one action formula or condition, try to think about breaking it up into steps that update a control or two then reference the control values in the final formula.  

On the other hand, if the scope of the action would require updating multiple controls simultaneously, you could also use an input table with multiple columns as a helper table instead. This method can help keep the number of elements in the environment from getting out of hand.  

Conditional Action Sequences 

Conditional Action Sequences are powerful tools for programmatic executions of action sequences. When working with conditional action sequences at times it almost felt like I was working with a tool as flexible as coding in Python (with a notable lack of loops). 

Here’s how to create a conditional Action Sequence:

1. Choose the element you want to host your actions sequence. 
2. Navigate to the actions pane.
3. On the three dots in the action sequence menu, select “Add condition.” 
4. Now you have two options: 
   1. Selection matches Criteria OR
      • With this you can specify how you want your selection to interact with the condition. One example of this is the “is not null” option. This allows you to trigger the action sequence only if something within the element has been selected (rather than the element itself for example).  
   2. Custom formula
      • This is where things get advanced. If you want your condition to reference multiple controls or variables, you will need to use a custom formula.  

Above: Here the action condition is set to ”Selection matches criteria” where the column ”Flightpath” is not null. Now the action sequence which navigates the user to a different page is only triggered when the user clicks on a valid flightpath. Without the condition, the user would be navigated anytime they selected the map element at all making navigating within the map itself virtually impossible.  

Stacking Conditions 

Whether by using selection matches criteria or a custom formula, action conditions are binary by nature. However, by creating multiple action sequences with different conditions developers can mimic ELSEIF logic to create complex logic in their data apps: 

This opens up a plethora of potential uses and makes me long for an implementation of python style loops. However, the current capabilities of the conditional actions are extremely powerful and versatile.  

Action Variables 

Action variables are just that: Variables created by actions. You may be familiar with action filters in Tableau and these behave somewhat similarly.  

There is one native action variable: Selection, but the user can also create new action variables by calling stored procedures from the data warehouse within the action sequence or by using Input Table actions.  

Action variables are native to the action sequence which creates them. Therefore, action variables cannot be referenced in an action sequence that did not create the action variable. 

The Selection Action variable  

Selection variables are extremely useful, not only in conditions, but also in updating controls. When the user triggers an action sequence on selection, a selection action variable is created based on which part of the element was selected. This can then be referenced by actions in that action sequence.  For example, if a user selected the first bar in the following bar chart: 

Two action variables would be created: One for each variable in the bar chart. The [Route] Selection variable would be filled with “Stillwater to Dallas-FortWorth” and the [Total Passengers] Selection variable would be filled as 90.  

The selection variable can be referenced like a column when writing formulas, but can also be referenced directly in some cases. It appears in this format: [Selection/’column name’]. This way you can target multiple columns based on the selected object in the right circumstance:  

Above: Note how the action condition ensures that the selection does not pull a null destination point — in this case, this means the action sequence only triggers when the user selects a point on the map, and not just the map in general. Next, a control is updated based on the name of the airport selected a different column.  

Row ID Action Variables 

Other action variables are created automatically when you update, insert or delete a row. These action variables capture the ID of the effected row. This means you can easily reference the same row multiple times in your action sequence without having to repeat the logic which identified the row in the first place.  

Action Variables which are created in an action sequence are exclusive to that action sequence. So, if you update a row in one action sequence, you cannot reference it in another. (But you could have the first action sequence update a control with the row ID which the second action sequence would then reference). 

Stored Procedure Action Variable 

There is another type of action variable, which is created when the user calls a stored procedure from the data warehouse. Stored Procedure action variables store the results of the stored procedure called in an action sequence.  

Calling Stored Procedures 

The ability to call stored procedures from the warehouse basically eliminates the limitations of cloud-based spreadsheet formulas in addition to giving businesses the ability to leverage their existing procedures and the insights generated from them.  

1. Make the procedure and save it in the data warehouse (make sure the permissions are correct) 
   • The procedure should not be created in the write back schema; but if the procedure is only being used in Sigma, it could be a good idea to keep it the same
     database.
2. Call stored procedure in action sequence to create action variable. 
   • Essentially this stores the results of the stored procedure as an action variable which can then be used later in the action sequence.  
3. Use the action variable named after the stored procedure in an action.  
   • This is where you connect the result of the stored procedure with what you actually want it to do in the workbook.  

Keep in mind that the name of the action variable generated by Sigma is a copy of the stored procedure title. This can get a little confusing if you are calling the same procedure multiple times in the same action sequence. The easy way to determine which action variable is generated by which call stored procedure action is order. The action variables will appear in the order they were created.  

Above: Here we generate a random integer to simulate rolling a die by using a stored procedure. In order to simulate the results of two die, I need to call the procedure twice. Notice how this creates two action variables with the same name, but each contains a unique randomly generated result. So, to use both I must be careful of the order I call them and subsequently reference them. 

Bringing it Together 

With its growing suite of actions and tools, Sigma creates a rounded Data App development experience. The sky is the limit here. The combination of advanced data management integrations, beautiful visualization capabilities and application features Sigma provides for a plethora of use cases.  

You can even push the tool far enough to create a functional, interactive D&D character sheet complete with dice rolling “animations.”  Please enjoy this playful application of advanced features.  

Above: The demonstration video showcases how different action sequences can be combined in order to automate complicated processes like those used in managing a TTRPG character sheet.  

It’s hard not to get excited about all the valuable tools Sigma brings to the table. If you are interested in learning more about Sigma or other data, IT and BI tools make sure to reach out and let us know what excites you! 

The post The Sigma Action Guide appeared first on InterWorks.

Jumping into the world of interactive data apps can be intimidating, and understanding how to set up input tables correctly is vital to creating a functional app. Luckily, InterWorks is here to help. We’ve created a concise guide to clarify how and when to use different types of input tables.  

Empty Input Tables

Empty input tables are just that. Literal tabula rasa. Like any blank spreadsheet, you can add anything you like to these, transform them, add calculations and use all of Sigma’s row-level actions on them. 

Empty Tables are great if you are building an app from scratch. These are often also necessary to create variables, formulas and references for other calculations.  

Empty input tables are limited by the fact that they must be built from square one. All data must be injected manually (although you can paste 50,000 cells from your clipboard). However, in the right scenario starting from scratch can set your data app up for success in the long run.  

This input table provides a list of values for data validation purposes throughout the app.  

CSV Input Tables 

CSV Imported input tables also allow for a lot of flexibility. You can upload a simple dataset to build from, and you can easily manipulate and add data to these tables, just like empty input tables.  

CSV Input tables are great if you do not need to update your data frequently or if data collection will be sourced through your data app in the future. Another use case for CSV tables is information tables with finite rows which may only occasionally need an update like the airport information table shown below.  

While they do provide great flexibility, CSV imports are not ideal if the base data source needs regular updates as you will have to redownload and upload the data from the source. Additionally, as of now CVS uploads have a limit of 200mb. However, this is still more efficient than pasting thousands of rows from your clipboard. 

Linked Input Tables 

Linked input tables are direct connections to your data warehouse. They stay in sync with your data and allow you to apply transformations and calculations as needed. Linked Tables require a little more setup than the other types of input table . First, you must create a table which connects to your data warehouse. Then, you can create a linked input table which uses that table as its source.  

Linked tables let you perform traditional BI tasks, and more. They are great when you have large datasets that are updated regularly. Even better when you want to add data app controls, such as comments or status indicators, horizontally to your table.   

Working with linked input tables is a lot like working with data in traditional BI software; you can manipulate the data as you see fit, but you cannot add rows to these tables (at least not without adding rows in your data source directly). Additionally, unlike Empty and CSV input tables, you cannot alter Linked tables on the cell level except in the columns you add.  

Note the plus symbol on the right indicates you can add columns, but there is no corresponding symbol for rows.  

Hybrid Input Tables

Hybrid tables are not an official type of input table in Sigma’s environment. Instead, Hybrid tables are a technique for getting the most out of multiple types of input tables. Let’s say you want to be able to add rows to your linked input table so that it can stay up to date from the warehouse and perform interactive row based what-if analysis through the app itself. You will need to make a hybrid input table.

First, connect to your data warehouse with a linked table (this can be an input table or just a normal table), and create any calculated field you need for your analysis. Next, create an empty input table and fill it with dimensions that match those of the linked table. Finally, create a union between the two tables. Now, you have a union which updates with your data warehouse and an input table which you can update directly from your app working together seamlessly.

To add data to your hybrid table, you simply add rows to the empty input table, and the union will update with the new data.  Hybrid tables are powerful but present potential data governance issues. If your data is being updated at the warehouse level as well as at the app level, there is potential for anomalies or duplicates to form; but they still have plenty of use cases, especially for things like what-if analysis and decision-making. Also, you must ensure you have the right permissions set up to make your hybrid table work. 

Here you can see where the data from the empty input table meets the data from the linked table to create a hybrid Input table.

Bringing It Together 

Here is a data structure we used which employed two types of input tables to create a functional data app.  

Note that the Linked Table and CSV Tables would play the same role in this schema as input tables.  

Also, here is a handy table for a quick comparison of the capabilities of the various input table types: 

Input Table	Can Write Horizontally	Can Write Vertically	Upload Size	Cell-Level Alterations
Empty			NA
CSV			200MB
Linked		☐	Unlimited	Only on columns you add
Hybrid			Unlimited	Only through the empty input table

Some Final Thoughts

Input tables are essential tools for building powerful data apps. Once you understand the strengths of each input table and how they can work together, you will be well-equipped to design impactful and interactive data apps in Sigma.  

The post 4 Ways to Use Input Tables for Sigma Data Apps appeared first on InterWorks.

Why Sigma? 

For many data users, dashboards represent the end of the data lifecycle. Data is ingested, transformed, cleaned, analyzed and finally visualized to support understanding and decision-making. Dashboards may have different filters or ways to change views, but even with the most advanced visualization capabilities, this is where the story ends for most tools. Sigma alters the paradigm.  

Sigma offers a powerful suite of visualization tools, but its capabilities are not limited to data preparation and visualization alone. In Sigma, data can be both visual and interactive; through Sigma Data Apps, decisions can be made inside of the tool itself and written back into the data. 

After I finished my first dashboard in Sigma, I could not help but crave more. Sigma’s suite of visual tools exceeded my expectation but I had not begun to dive into the aspects of the tool which make it unique. It was time for an upgrade. 

Popovers

The first unique tool I leveraged was one of Sigma’s newer features: the popover. Popovers are containers that appear on the screen only when activated. Additionally, they appear near where the popover button is placed. The cool thing is that they can be opened by any other element on the screen.  

This allows developers to control what digital real estate will be taken up by the temporary container. One common use case for popovers is to create an expandable and compressible filters pane. This is exactly what I did. and speaking of digital real estate- wow! By using this one simple feature, I gained back a sizable portion of the screen. 

Now, users can focus more of their attention on the interactive map. The map also received an upgrade.  

Navigation

Sigma’s action system makes page navigation a breeze. I found it intuitive to set a conditional action that navigates the user only when they select a predefined part of the visualization, and then sets a filter control to the selected value.  

In our case, selecting a flightpath navigates the user to the “Routes” page and filters the data to the selected route.  

Next, a user can click on an airport name in the “Flights” table and be brought to a detailed view of the information for that airport.  

This gives our data app seamless drill-through and drill-across capabilities. Sequences of actions clear and set filters or controls, navigating the user between pages with ease. The experience developed through Sigma’s navigation tools is both satisfying and intuitive. The next satisfying feature helps maintain consistency across the  app while the user flies from page to page.  

Synchronized Controls 

Remember the filter popover from before? Well, there are three popovers in our app filled with synchronized filter controls. Popovers are stored in a particular sheet where the popover button is located. However, I wanted users to be able to access the global filters from any page. How can this be achieved in Sigma? All developers must do is duplicate the popover, then create synchronized duplicates of each filter within the popovers. 

Now, when a filter is changed on one page, it is also changed on the other pages. Altogether, these synchronized popovers create the illusion of a single popover with controls that remember their settings from other pages.  

Input Tables 

I wanted to create not only a cool and interactive dashboard, but a functional data app where InterWorks’ team could not only analyze our carbon footprint but also interact with the data. Input tables are the heart of Sigma data apps, by using them developers can easily empower users to update or add to existing datasets. By turning the CO2 emissions dataset into an input table, that can be altered by Sigma’s row level actions, we officially cross the line from dashboard to app. Let us imagine a user who wants to add a new flight to the dataset but does not want to have to return to the data warehouse to achieve this. 

The user will start by clicking a button which opens a modal: 

Notice how the controls for the airport code are preset for the origin and destination of the route page we were already looking at. Sigma’s actions make setting up a smooth user experience easy.

In this case, the modal contains a form which can be submitted to fill new data into the input table. The ability to make and modify input tables opens up a plethora of use-cases for Sigma. In our scenario, now users are not only able to see patterns in company carbon emissions, but also can update the app with more information. Additionally, input tables can be saved back into a data warehouse, which has implications for a myriad of use cases.  

Taking It to the Next Level 

I envisioned an application where employees could request company flights, and supervisors could review those flights and approve or reject the request based on the insights drawn from the visualizations – all hosted in the same app!  

Here we see a table depicting flights with different states of approval in the STATUS column. Supervisors can click on a row in the STATUS column to update that flight request by completing the form on the modal below.

The best part is that those results are then saved back to the data warehouse, completing the data lifecycle. Data ingestion, insights and decision-making all in one place. Fully functional end-to-end data apps are entirely possible in Sigma.  

Now We Are Getting Excited!  

The possibilities for this tool are limitless. Keep a lookout for more Sigma blogs, guides and visualizations soon. What gets you excited about data apps? 

Happy analyzing! 

The post Transforming a Dashboard to a Decision App with Sigma appeared first on InterWorks.

As a Tableau, Power BI and Excel user, the idea of a spreadsheet based BI tool struck me as an interesting concept. I had heard that Sigma had a powerful visualization toolset, but l lacked some of the customization options of more traditional BI tools. In return, Sigma offers a UI which is extremely friendly to spreadsheet users, as well as powerful data application capabilities.  

Before diving into the advanced tools Sigma has to offer, I wanted to explore the tool’s more traditional BI visualization capabilities. So, I loaded up an interesting dataset through InterWorks’ in-house Snowflake connection and got to work. 

Data Preparation with Sigma 

The first thing that impressed me about working in Sigma was the data preparation phase. The data preparation phase is where spreadsheet users will be most comfortable as this part of the process is done almost entirely in a spreadsheet interface.  

Being able to easily see and alter your data in its raw form is transformative to the data preparation experience. Using the formula bar, you can easily create new calculated columns and validate the results against raw data in real time.  

I was working with InterWorks’ consultant flight dataset and had to join this dataset with public information on where airports are located so I could then visualize the flight paths that InterWorkers were taking.  

The join was the first true test of Sigma as a proper BI tool. I found the experience to be intuitive as Sigma provides feedback to the user along the way through information about their join.  

As shown above, Sigma displays information about the joining keys, including how many unmatched keys are on each side of the join. This gives the user critical information on whether their join will be successful.  

Additionally, Sigma gives the user full flexibility to choose which columns to keep from each data source, reducing noise in the finalized output. On top of the intuitive UI, the cloud native Sigma was able to handle advanced join operations without significant delay.  

With data preparation complete, it was time to put Sigma’s suite of visualization tools to the test.  

Data Visualization in Sigma 

When creating visualizations in Sigma, Tableau users – and perhaps even more so Power BI users – will find themselves in a familiar environment. You place the chart you want to create in the worksheet, drag columns into the appropriate axis and fiddle around with formatting to your heart’s content.  

Naturally, some features were in different places from other BI tools. However, after adjusting my senses and locating everything, I found navigating around Sigma’s UI to be a straightforward process.   

I found the flow of working with Sigma’s visualization tools to be quite intuitive. You can organize visualizations into handy containers and even switch the data source of a visualization without a hitch (if the column names are the same).  

I was especially impressed by the tabbed containers feature. This allows developers to layer visualizations on top of each other, and it allows users to easily cycle through those visualizations by simply clicking on a tab.  

I also enjoyed using the Buttons and Actions features. I felt like I only scratched the surface of the potential use cases for these logic driven tools when using them to embed links or create filters.  

So, with all these tools and features, what was this first-time user able to create?  

My First Sigma Dashboard 

What I built is a comprehensive and dynamic look at InterWorks’ carbon footprint from 2021 to 2022 through company airplane travel. Take a look at the screenshot below. 

Although InterWorkers are not traveling at the rate we were before the pandemic, the trends show that we are beginning to travel once again as we grow as a company. This comes with a notable increase in international travel.  

Please feel free to explore the dashboard for yourself and see what insights you can find! 

What I Am Excited to Explore Next in Sigma 

Doing this first pass with basic formatting has got me excited. My work here just scratches the surface of Sigma’s full visual design capabilities. Sigma’s diverse and powerful suite of BI tools allows the user amazing flexibility. Additionally, Sigma is growing and consistently adding new features to its already diverse suite of capabilities. Indeed, in Sigma’s current state (including beta features like Tabbed Containers), the tool can adequately serve many business use cases and even has some advantages over mainstream BI tools.  

Even by its data preparation and visualization features alone, Sigma is already an exciting tool to explore in the BI space. I hope to write more about these functionalities and how to get the most out of individual features. However, I am most excited to dive deeper into the features that truly make sigma unique – input tables, action, modals and more.  

Sigma has amazing documentation and is starting to expand its training network as well, but InterWorks is also here to help! Please let us know what you think of Sigma or if you have any questions here.  

Happy analyzing! 

The post My First Sigma Dashboard: Unpacking a Suite of Visualization Tools appeared first on InterWorks.