Xilution Blog

Xilution Stacks are Ready for Beta Testing

By Todd Brunia
Xilution Stacks take the guesswork out of building and deploying resources into the cloud. Our stacks are assemblies of Xilution Pipelines and other cloud centric resources that form a cohesive web development solution.

Photo by Lidya Nada on Unsplash

Provisioning a stack is fast and easy. What once once took days or weeks for web development teams to do can now be achieved in minutes.

To provision a new Xilution stack, simply select a solution from a list of ready-made stack templates, provide us with some input parameters, click the "Provision Stack" button, kick back and we'll take care of all the DevOps details for you.

Best of all, we've baked years of DevOps and web development experience into our stacks and pipelines, so you'll know your project will start off on the right foot on day one.

Stacks templates are reusable and extendable.
  • Select from a list of curated public stack templates published by the Xilution and other Xilution users.
  • Build upon what others have achieved by copying a stack template into your own organization and customize it for your needs.

Select from an ever growing list of solutions based on a diverse collection of frameworks. Our curated list of public stack templates includes API, Single Page Web App and WordPress solutions to name a few.

Want to learn more about how Xilution Stacks can help your web development team?

Follow the Xilution Kangaroo Build

By Todd Brunia

We have set a new challenge for ourselves! All new Xilution development will run through our #NoOps pipeline products.

Our first dog fooding adventure is Kangaroo, an API for managing cloud account details on behalf of our customers.

We plan to use a few different Xilution products for this project including...

  • Fox (Managed API NoOps pipeline)
  • Zebra (OAuth2 compliant authentication API)
  • Beagily (Simple data storage API)
These products span the breath of our product offering including pipeline, IAM and API products, and we're excited to show them off for you.

In the spirit of building in public, we're sharing our progress under the hashtag #XilutionKangarooBuild on Twitter. So, follow the action at @xilution or @tbrunia.

If you follow along, please let us know what you think and please kindly share our story with others. Thanks!

How To Set Up a Static Web Content Pipeline with Coyote

By Todd Brunia

What is Coyote?

Coyote is Xilution's static web content pipeline solution. Static web content includes any non-changing resource delivered to a web browser from a web server. This includes HTML markup files with the "html" or "htm" file extensions. This also includes image files such as "png" and "jpg". A dynamic user experience can be provided through JavaScript files which are also considered static content. JavaScript frameworks like React and Angular can be used to provide a rich user experience and are compatible with Coyote.

Like all other Xilution pipeline products, Coyote features ready-made AWS infrastructure in convenient t-shirt sized choices. Coyote integrates with your source code through GitHub. If you're curious, Coyote uses xilution-content-delivery-coyote-ci to determine how it executes and which resources are provisioned into your cloud account.

The following diagram describes a Coyote pipeline in detail.

Coyote Pipeline
Click to Enlarge

The following instructions explain how to set up a static web content pipeline using Xilution Coyote. Before you set up the pipeline, you'll need to complete some provisional steps.

Create a New AWS Account

The Xilution platform provisions and deploys resources into an AWS account that you own. We call this "bring your own cloud".

We recommend that you create a brand new cloud account when interacting with the Xilution platform. A clean account reduces security risk.
  1. Open the AWS home page.
  2. Click the Create an AWS Account button in the upper right hand corner.
  3. Make note of new account number. You'll need this later.
Note: You are responsible for fees incurred through the use of resources provisioned into your cloud account by the Xilution platform. These fees are paid directly to your cloud provider through your cloud provider account.

Prime your New Cloud Account

Priming provisions resources into your AWS account that grant Xilution permission to manage and monitor your account on your behalf.

Click the Launch Stack button below to prime your AWS Account.

AWS Quick Launch

If you're curious, here's a link to the AWS CloudFormation Template that's used to prime your account.

Create a Xilution Account

After you have provisioned your AWS account, browse to https://register.xilution.com and create a new Xilution account.

Note: You can try Xilution for FREE through our generous new account credit offer. Email info@xilution.com for details.

Activate Coyote

  1. Once you've created a Xilution account, browse to https://portal.xilution.com to access the Xilution account portal.
  2. Once you're logged in, browse to https://portal.elephant.basics.xilution.com to activate Coyote.
    1. Click on the "Go To Your Organization" button.
    2. Click on the "Actions" drop down button and select "Activations".
    3. Scroll through the Product Activations until you find "Content Delivery"/"Coyote" and click on the "Activate" button then click the "Close" button at the bottom of the modal.

Set Up the Example Coyote Pipeline

  1. Once you've activated Coyote, browse to https://portal.coyote.content-delivery.xilution.com to create a new Coyote pipeline.
    1. Click on the "Select an Organization" button.
    2. Click on your organization's name to select your organization.
    3. Click on the "Actions" drop down button and select "New Content Delivery Pipeline".
      1. In the "New Content Delivery Pipeline", enter the following...
        1. Name: Coyote Demo
        2. Provider: AWS
        3. Cloud Account ID: Your AWS account ID.
        4. Region: Your AWS region.
        5. Stages: [{"name": "test"}]
        6. Source: https://github.com/xilution/xilution-content-delivery-coyote-example.git
        7. Branch: master
        8. Pipeline Type: Small AWS Content Delivery Pipeline
      2. Click the "Submit" button.
    4. Click on your new pipeline configuration.
    5. Click on the "Actions" drop down button and select "Provision".
      1. When prompted, select "Confirm".
    6. Click the "Refresh" button periodically to see the pipeline status update.
    7. The pipeline will take about 10 minutes to provision and deploy the first time it's run.
    8. When the pipeline has completed successfully, you'll be able to click on the site links in the Stages section to see your static web content in a browser.
That's it! You've set up the Example Coyote pipeline. When you are finished, you can select the "Deprovision" button in the "Actions" drop down to deprovision Coyote infrastructure from your AWS account.

Extra Credit

  • Check out the Coyote example source, open the xilution.yaml file to see how you can set up testing.
  • Browse through the Execution history.
  • Try the "Run Now" or "Reprovision" buttons in the "Actions" drop down.
  • Delete the Coyote Demo pipeline and recreate it.
  • View the resources Coyote has provisioned in your AWS account.

Next Steps

Try Xilution for FREE!

By Todd Brunia
The next 10 registered Xilution accounts will receive $500 USD in Xilution credit. Good for 6 months from time of registration. Includes concierge service!
Visit https://register.xilution.com to create a new Xilution account. This offer is limited, so act quickly. #DevOps #NoOps

Request a Demo

By Todd Brunia
We're looking to partner with up to ten digital marketing agencies to beta test our new dev-ops platform.

We've invested two years building a turn-key dev-ops platform for small to medium sized digital marketing agencies. Our platform is inspired by similar platforms custom built by large corporations and their internal dev-ops engineering departments. If your digital agency doesn't have an internal dev-ops engineering department of your own and would like to experience how the Xilution platform can save you thousands in dev-ops engineering costs, contact us today and request a demo. Availability is limited, so act now!

Email info@xilution.com to request a demo today!

Lynn Swanson Joins Xilution as COO

By Todd Brunia
We're excited to announce that Lynn Swanson, @swansol, has joined Xilution as Chief Operating Officer.

Profile photo for Lynn

Lynn has over 20 years experience as a project management professional (PMP) and in operations management. Her key skills include analytical problem solving and developing best practices. In her new role, Lynn will focus on business development and day-to-day business operations. Additionally, her extensive communications experience will be leveraged to take Xilution to the next level.

Welcome to the team, Lynn!

Todd Brunia, Presents to 1 Million Cups - Des Moines

By Todd Brunia
On Wednesday, September 11th, Todd Brunia, Xilution founder, presented to 1 Million Cups - Des Moines.

Todd shared an abridged version of Xilution's pitch deck with those in attendance. Todd fielded lots of great questions about Xilution products and services and made lots of great connections following the presentation.

Todd plans to repeat the presentation with other 1 Million Cups organizations around the state of Iowa in the near future.

To learn more about Xilution, email info@xilution.com.

Beagily and GraphQL Make a Great Pair

By Todd Brunia
GraphQL has been exploding in popularity with frontend developers over the last few years. So, we thought it would be cool to see how well GraphQL and Beagily, our simple JSON data storage API, paired together.
Long story short, we found that GraphQL and Beagily make a great pair and we are pleased to share our proof of concept with you. Check it out for yourself by following the link below!

As an added bonus, the POC's readme includes instructions on how to run an instance on Fox, our managed API hosting service.

Let us know what you think by tagging us (@xilution) on Twitter!

Fitment Builds a Resource Scheduling Service Using Xilution APIs and Professional Services

By Todd Brunia
Damon Gentry, founder of Fitment, is creating a digital service for businesses that market reservable activities. Ironside Axe Club, Damon's first subscriber, is an ideal fit for Fitment's new service.

Image result for axe throwing target

Ironside Axe Club's business is growing rapidly. That growth has led to some challenges with the reservation software they currently use which was designed for the hair salon industry. At the time they choose the system, it was about the only option available. Needless to say, it doesn't quite fit their business model. It falls short of their correspondence expectations and offers no way to integrate with a system they used for staff scheduling.

Damon, who has experience building online reservation systems, jumped on the opportunity and offered to create a platform that consolidated these two systems into a cohesive scheduling solution for Ironside Axe Club. Ironside Axe Club, who is eager to improve their online reservation process ahead of the World Axe Throwing League U.S. Open Tournament to be held at their West Des Moines location at the end of August took Damon up on his offer.

With a new project in hand, Damon set out to assemble a solution for Ironside Axe Club. That's where Xilution comes into the picture. Damon and I met in May. Shortly thereafter, Damon learned about the Xilution platform and how it could help him build his solution.

Damon needed two things to achieve a minimum viable product for Ironside Axe Club. First, he needed an alternative to the reservation system that Ironside Axe Club had grown frustrated with. Second, he needed a way to coordinate reservation transactions between the alternative reservation system and the staff scheduling system that Ironside Axe Club was satisfied with.

I offered to create a resource scheduling API to address Damon's need for an alternative reservation system. I also offered to create a managed API hosting solution to address Damon's need for a way to coordinate reservation transactions. This is how two new Xilution APIs, Honey Bee and Fox, were born.

In addition to API products, I also supported Damon through Xilution Professional Services. I helped Damon code a middle tier component and a frontend widget. The middle tier component, hosted on Fox, coordinates reservation transactions between Honey Bee and Ironside Axe Club's staff scheduling system and communicates with the frontend widget, to be embedded in the Ironside Axe Club's website, via an RESTful web service interface.

Working with Damon on his resource scheduling platform has been a lot of fun and has served as a great proving ground for my startup's business model. It resulted in the creation of some new APIs which are now included in the Xilution portfolio of API products. It also shed light on the opportunity to offer professional services to Xilution's API customers. I think the experience will have a lasting impact on Xilution for years to come.

If you would like to learn more about how Xilution can support your digital marketing efforts, contact tbrunia@xilution.com today!

Beagily in 15 Minutes

By Todd Brunia
I created this mini tutorial to help coders quickly learn the Beagily basics. Beagily is a simple JSON data storage API.

  • Great for prototyping and rapid concept validation.
  • You define the structure of your data through the API as JSON Schema which supports.
  • You control who has access to data by assigning ownership to records.
  • Only pay for what you use pricing.


  1. Create a Xilution account in our Test environment.
    1. Restricted access to Beagily is provided for FREE in our Test environment. See the Beagily product details page for pricing and restriction information.
  2. Activate Beagily through our Account Admin Portal in our Test environment.
    1. To activate Beagily (or any other Xilution product for that matter), log into the Account Admin Portal in Test and navigate to the Products page.
    2. Beagily may have been automatically activated when you created your account.
  3. Look up or create a Xilution Client.
    1. You'll need a client ID to request a Xilution Access Token.
    2. To see the clients associate with your Xilution account, log into the Account Admin Portal in Test and navigate to the Clients page.
  4. You'll need a way to interact with the API. We recommend the Insomnia REST client, but you could use any similar app. You could also simply use cURL as well.
Note: At the time of this writing our Test and Prod accounts are not synchronized. So, if you choose to use Beagily in our Prod environment, you'll need to repeat these step in Prod.


Beagily (along with all other Xilution APIs) uses the OAuth 2 authentication. To acquire a Xilution Access Token...

POST: https://test.authentication.core.api.xilution.com/oauth/token


Response: The response will include a property named access_token. This is your Xilution Access Token. It is a bearer token. You will included this as a request header called Authentication with each subsequent request mentioned in this mini-tutorial. The value of the header will take the form of: Bearer {your-xilution-access-token}.
Note: The format of the this Post body is x-www-form-urlencoded and should be URL encoded.

Create a Type

Beagily uses schema defined by you to validate things that you POST and PUT to the API. You register your schema with Beagily like this.

PUT: https://test.beagily.basics.api.xilution.com/types/pet

  "$schema": "http://json-schema.org/schema#",
  "title": "Pet Schema",
  "type": "object",
  "properties": {
    "@type": {
      "enum": [
      "type": "string"
    "owningUserId": {
      "type": "string"
    "name": {
      "type": "string"
  "required": [

Remember: You need to include the Authorization header with this request and all the following requests.
Note: @type and owningUserId are required thing properties in Beagily. The type name and the enum are both singular.

If you want to see your pet type you can...

GET: https://test.beagily.basics.api.xilution.com/types/pet

Create a Pet

POST: https://test.beagily.basics.api.xilution.com/things?type=pet

  "@type": "pet",
  "name": "Muffy",
  "owningUserId": "{your-user-id}"

Response: The response headers include a Location property that includes the identifier of the new pet.
Note: As before, the type name is singular.

Update the Pet

PUT: https://test.beagily.basics.api.xilution.com/things?type=pet

  "@type": "pet",
  "id": "{the-pet-id-found-in-the-create-response-location-header}",
  "name": "Dusty",
  "owningUserId": "{your-user-id}"

Note: As before, the type name is singular.

Get the Pet

GET: https://test.beagily.basics.api.xilution.com/things/{the-pet-id-found-in-the-create-response-location-header}?type=pet

Note: As before, the type name is singular.

Search for the Pet

GET: https://test.beagily.basics.api.xilution.com/things?page-size=10&page-number=0&type=pet

Response: The response will be the pet that you posted earlier including the ID and some other meta-data.
Note: Pet is singular again and the page index is zero based.

If you want to narrow the search, add a filter using the q query parameter...

GET: https://test.beagily.basics.api.xilution.com/things?page-size=10&page-number=0&type=pet&q=name:Dusty

Other Resources

Wrap Up

Hope this mini-tutorial inspires you to give Beagily a try and helps you quickly get up to speed with the Beagily basics. If you find the instructions need more context send us an email at support@xilution.com and we'll make the needed changes. Happy coding!