What happened?

There haven't been any new updates from us at Enterspeed in the last couple of months. There hasn't been anything except the sound of silence.

But fear not; there's no darkness here.

We have been busy optimising and tweaking our processing layer, making it run like a smooth, well-oiled machine.

You see, we experienced an incident with a backlogged processing queue at the beginning of January. This incident caused us to throw everything in our hands and optimise our processing layer with multiple small and large improvements.

This update will show what we've been doing in Enterspeed for the last couple of months and what we have done to avoid similar incidents.

Fair processing

Processing is usually very straightforward: One source entity is ingested, and a transformed view is ready for the Delivery API in a few seconds. 

And this works very well. However, at other times, the processing process becomes more complicated. 

Examples of more complicated processing scenarios are, e.g. a schema deployment or a re-ingest of all source entities. 

Processing in these scenarios results can result in many thousands of processing jobs. Thus processing time is not as instant as in the 1:1 source entity to view scenario.

That is by design, and we don't claim or even want to scale to instant processing times when the volumes become large. So this pre-processing model comes with some latency tradeoffs. But the problem was that one customer could affect other customers, and nobody likes noisy neighbours.

This is, of course, not something we can accept, and we have therefore implemented what we call a "fair processing queue". Without going into too much technical detail, we can now regulate how much processing time is available for different classes of tenants and different types of processing jobs. 

Overall, this allows us to remove the noisy neighbour problem so that all tenants will experience that ingesting a source entity will result in a generated view a few seconds later. 

The more complicated processing scenarios still create roughly the same number of jobs. We want to underline that the fair processing queue allows multiple customers to share the same resources fairly. 

Both from a cost and sustainability perspective, this was the design requirement in the fair processing queue concept we wanted to introduce.

So, we are thrilled with the design and performance of the fair processing queue.

No more over-processing

Another issue in those dark hours at the beginning of January was what we internally call "over-processing". 

In some cases, updating one source entity resulted in a spike in processing jobs. 

One of the key features of Enterspeed is that the developers need to worry less about cache invalidation and leave that to Enterspeed. 

In the inner details of these features, we found two bugs that triggered the re-processing of too many source entities. Re-processing too many source entities and a shared queue were the two main issues for the incident in January. 

Of course, we fixed the two bugs, but we also added a feature to the new fair processing queue: job de-duplication. 

We can now detect duplicate jobs within the same batch of processing jobs to reduce the overall number of jobs. 

This saves time and results in a win both for costs and sustainability. 

Death by a thousand paper cuts

The last thing we want to mention is the small optimisations.

When working with hundreds of thousands of processing jobs - and we saw millions at peak - all the small inefficiencies start to add up to large numbers. 

And this is one of the cool parts of working with some really large numbers; the small optimisations make a real difference. 

One of the really interesting things was an unexpected behaviour from a specific IoC container registration that caused a spike in CPU usage. 

We ended up removing all applicable IoC container registrations of IEnumerable<>, to optimise CPU usage. 

We also made several changes to how we query data from our data store. 

So if you want to learn more about continuation tokens and point reads in Cosmos DB, don't hesitate to get in touch. 

Another tweak to our datastore was to move more of the Cosmos DB containers to tenant-specific containers for our Enterprise tier.

Overall we are very pleased with the changes, optimisations and tweaks we have introduced. 

As with all software, we continue learning from our customers - you, our excellent technology partners - as the platform is being used for more than we imagined.

Until next time 👋

Just call us The Pointer Sisters because, boy, are we excited! And no way we’re going to hide it. 

This edition of Enterspeed Product Update contains so many incredible things. 

So… Let’s get excited!

feature CLI 1.0

We teased in our last EPU that the CLI (Command-line interface) would soon see the light of day. That day has finally arrived. We’re proud to announce version 1.0 of the official Enterspeed CLI.

The Enterspeed CLI lets you work with your tenant for all sorts of tasks, for instance:

• Managing environments
• Managing source groups
• Creating and deploying schemas
• And much more…

You can either work with the CLI locally, or you can implement it in your CI/CD pipeline – whatever fits your workflow.

Head over to the CLI documentation to see how you can get started using it. 

You can also check out this introduction video that our colleague Jesper W. made.

feature Schema snippets

We love coding. But sometimes less is more, which is why we base our schemas on low-code principles. 

Often you want to get something done quickly and efficiently without manually having to type a lot of code.

Well, we got your back, Jack. We’ve made it even easier to create your next schemas thanks to our new schema snippets feature.

Simply start typing the name of the field, property type, or example schema you want to use, and a list of options will appear in the editor. Click the tab button and BAM! You got yourself some code 👨‍💻

How easy is that?

We currently support the following shortcuts for schema snippets:

• "triggers" (field)
• "properties" (field)
• "route" handle (field)
• "route" URL (field)
• "actions" (field)
• array (property type)
• object (property type)
• reference (property type)
• partial (property type)
• dynamic (property type)
• Example schema: Breadcrumb navigation
• Example schema: Category products
• Example schema: Map all source entity properties
• Example schema: SEO Composition
• Example schema: Site settings
• Example schema: Top 3 product reviews

feature Schema versions overview

Do you know what can be a pain in the neck to keep track of? Different schema versions deployed to different environments independently of each other.

That is why we created a “Versions” overview page. It lets you see exactly which version of your schema is deployed to which environment.

Neat 📸

feature Schema compare versions (diff checker)

Well, now you no longer have to (even though we can understand if you still want to be like Travolta, he’s got some sweet dance moves) thanks to our “schema compare versions” functionality.

On your schema page, simply select the version you want to compare with, and a “diff checker” will appear, highlighting all the changes from the previous version.

You can even edit your current version at the same time.

feature commercetools integration

Our last few integrations have been focused on traditional CMS, but now it’s time to dive into a new category. This time with one of the worlds leading commerce solutions, commercetools.

commercetools, founded in 2006, is a cloud-based headless commerce platform with customers around the world. 

We’re so happy that we're now able to support these customers with this integration.

The integration lets you import your product, variants, and categories into Enterspeed.

GitHub link: https://github.com/enterspeedhq/enterspeed-source-commercetools 

feature Contentful integration (beta)

We have also developed a new integration to Contentful, the cloud-based CMS. With this integration, you can ingest your content from Contentful into Enterspeed.

The integration is now in beta and does currently not support all events and data types in Contentful. 

GitHub link: https://github.com/enterspeedhq/enterspeed-source-contentful-cp 

feature New Umbraco integration

One of our most popular integrations, our Umbraco integration, has just had a major update. To make things easier for users (and for us), we have unified our different Umbraco integrations into one, starting from Umbraco 9.

This makes it easier to update for the users, easier for us to maintain, and much easier for everyone to navigate the documentation.

The new unified integration supports Umbraco 9, 10, and 11, as well as all future Umbraco versions.

We have also added support for the new Block Grid Editor for Umbraco version 10.4 and version 11.

You can read more about the integration right here: https://docs.enterspeed.com/integrations/umbraco/getting-started

Improvement Unopinionated “Getting started” tutorial

We have made quite a few demos and articles based on exciting frameworks like Next, Nuxt, Astro, you name it. 

But sometimes you may not feel like having the Chocolate chip cookie dough ice cream with sprinkles and whipped cream on top. Sometimes you just feel like… Vanilla.

That is why we’ve created an unopinionated “Getting started” tutorial, completely free of any CMS or framework and simply based on good old “vanilla” JavaScript.

You can find the tutorial right here: https://docs.enterspeed.com/tutorials/creating-a-simple-site/intro 

Improvement Redeploy schemas

This is the good old “Have you tried turning it on and off again?” – but for schemas.

Sometimes stuff happens. For one reason or another, you might need to generate a new view without needing to update your source entities. 

This can easily be done by creating a new version of your schema and deploying it. But that quickly gets annoying if you need to do it multiple times – and you risk ending up with a lot of versions of your schema. 

We have introduced an easier way to do this. In the bulk deploy pane, you now have the option to redeploy already deployed schemas, meaning the version will stay the same but will trigger a regeneration of your view.

Improvement Create schemas directly in folders

In the last edition of EPU, we introduced schema folders, and boy, where you guys existed. That's until you realised that you had to prepend the folder name in the schema name in order to place it in the folder.

Then suddenly, it felt like being back in 2012 with some of you saying, “Ain’t nobody got time for that!”.

Don’t worry, we get it, which is why we've made a shortcut button for creating schemas directly inside your folders. 

Improvement Prefill types upon schema creation

This last improvement is yet another benefit for us lazy people. Yay!

When creating a schema, we previously introduced the option to prefill your source in the schema. Now we have taken it one step further by also enabling you to select source entity types.

These source entity types will automatically be added to your schema’s triggers inside the data source.  

fix Fixes and tweaks 🛠️

•    Source entities filters are now saved when navigating to a single entity and back.

•    Umbraco integration: Fixed that media domain was not added to all media types.

•    Improved visibility of dropdown labels in dark mode.

Until next time 👋

In this Enterspeed Product Update, we got a lot of schema-related goodies for you. Not only is it now easier to quickly create a schema – but we have also introduced a new way to keep them organised.

And as always, we got a lot more up our sleeve – so let’s dive in.

FeatureSchema folders

When building large sites, you often need to create a lot of specific schemas. As the number of schemas grows, so does the complexity.

You guys started asking for a better way to organise and keep track of your schemas. And just like a mad scientist we grabbed our lab coat (hoodie) and headed straight to the lab (VS code).

The result is schema folders. Instead of having all your schemas in one long table, you can now organise them into folders.

Simply add a slash (/) in your schema name and the text before will be transformed into a folder – pretty neat!

To keep it easy and manageable, we've limited the number of folder levels to two. This means you can organise your schemas into folders and subfolders.

For instance, a schema with the name “Global/Various/Link” will be transformed into a schema with the name “Link”, located in the subfolder “Various”, which is located in the folder “Global”.

Neat! To quote old Benjamin Franklin: “A place for everything, everything in its place”.

feature Prefill your schemas upon creation

Now it’s quicker and easier to create a schema. When creating a new schema, you now have the option to select a source.

Selecting a source will automatically prefill your schema with the available source entity types. We've also created a “dynamic mapping”-property, which lists all the data available for the source entity. That way it’s easier to quickly test your sources.

feature Create references across data sources

When creating a reference, you are now able to define a different source. You do this by adding the “source”-property and making it equal to the desired source group alias.

By that, you now can use a view that isn't in the same source group as the rest of the schema.

Please note, that the “source”-property only can be used if “originId” is used. If “id” is used the source of the id will take priority over the source.

feature V2 Delivery API

We released a new version of our Delivery API – version 2. The new version now supports multiple handles for the same schema.

In version 1 the schema alias is used as the key for a handle. Because of that, it’s not possible to fetch multiple handles of views generated by the same schema.

In version 2, however, the key is changed to the handle name, meaning that you can fetch multiple handles even though they are generated by the same schema.

Second, we have removed the id, type, and view property and made the view data inline for view references – making it much cleaner for the client. 

Last but not least, we’ve added the "missingViewReferences" in the meta field, which makes it easy for you to debug missing view references. All missing view references get listed here with the id of the missing view and a path of where the view is missing. 

Improvement Source group is now displayed in source dropdown

When selecting a source on the Source entities page, Generated views page, etc. you can now see which source group each source belongs to.

Thus, you can easily distinguish between similarly named sources.

Improvement Duplicate partial schema

Need to duplicate a partial schema? No problem.

You can now easily duplicate your partial schema, just like you can your regular schema. Select “duplicate” in the settings menu, which you’ll find in the partial schemas overview.

Improvement Avoid accidentally deleting environments

Friends don’t let friends accidentally delete an environment in use!

And at Enterspeed, we’re most definitely your friend, so we’ve made sure this won't happen on our watch.

As a security, environments that are referenced from a data source or environment client can no longer be deleted.

If you need to delete an environment, you will first need to unlink it from your data source and/or environment client.

Improvement Dedicated resources for Enterprise plan customers

Ever tried dealing with noisy neighbours? Yeah, not much fun. You might have thought: “I would pay anything to have some peace and quiet.“

If you go Enterprise with Enterspeed, then you can.  We've taken the first steps towards providing dedicated resources for our Enterprise plan customers. 

As both we and our customers grow, a predictable processing speed is important for us.

By dedicating a slice of our processing layer to individual enterprise customers, we've effectively eliminated noisy neighbours for them.

fix Fixes and tweaks 🛠️

• The save schema shortcut (Ctrl + s) is available again.
• Source entities with null properties no longer cause NPE for subsequent ingests

…We have also added a bunch of features and fixes to our Umbraco Source connector – head over to the changelog to view more!

🤫 Teaser The Enterspeed CLI

A highly requested feature will soon see the light of day – the Enterspeed CLI.

Our skilled engineers have been working tirelessly on the first version of the Enterspeed Command Line Interface.

We’re really excited to share this with you all. The CLI will bring a whole new way of working with Enterspeed, by having it available via your favourite IDE.

Soon we will be letting the first few customers try out our beta, so we can get some feedback before releasing it.

If you’re interested in testing it out – feel free to drop us an email at info@enterspeed.com

Until next time 👋

You can say that Christmas has come early for all you Umbraco-users out there – and just like Santa’s bag, this product update is filled with existing things.

And don’t worry, unlike Santa we won’t ask if you’ve been naughty or nice.

feature Umbraco V10 integration 🔌

We’ve added yet another integration to our stack – the Umbraco V10 integration.

Umbraco V10 is the latest version of Umbraco and brings a lot of existing features, for instance, SQLite support, .NET 6 and ASP.NET Core 6, Nullable reference types, and much more.

The integration is available on GitHub and via NuGet. You can find more information about the integration in our documentation.

Documentation: https://docs.enterspeed.com/integrations/umbraco/umbraco-v10/getting-started

GitHub: https://github.com/enterspeedhq/enterspeed-source-umbraco-cms

NuGet: https://www.nuget.org/packages/Enterspeed.Source.UmbracoCms.v10/

Now you’re maybe thinking “Aw, snap! I’m only using Umbraco V8 – I wish there were an easy way to upgrade”. Well then, get ready to get your mind blown 🤯

feature Enterspeed Migrator 🚚

Imagine this. You are using an older version of your CMS, this could be Umbraco V8, and you want to update to the latest version (in this instance Umbraco V10).

How do you do this easily and painlessly, without it affecting your live website? You use Enterspeed and our latest extension, our Enterspeed Migrator.

The Enterspeed Migrator currently works in Umbraco V10 and lets you copy all your templates and content into your Umbraco V10 instance.

The way it works is by fetching the source entities ingested into Enterspeed and then building your templates and content in Umbraco.

Look at this video of how we migrated from Umbraco V7 to Umbraco V10 in no time: https://www.youtube.com/watch?v=8DOUJpbc6CM

That’s pretty wild. Do you know what’s even wilder? We also did this from a Sitecore site to a new Umbraco site. That’s right. We changed the freaking CMS, which was almost as easy as changing your bed linen 🛌

Imagine the look on your manager's face, when you do a migration that usually takes days (depending on the size of the site), in the time it takes you to drink a cup of coffee.

Insane.

You can find the Enterspeed Migrator here: https://github.com/enterspeedhq/enterspeed-migrator

Improvement Umbraco Media support 🖼️

Our Umbraco integration now also supports Umbraco Media, meaning source entities will automatically be created in Enterspeed whenever you save a media item.

If you save a folder in Media, all its content will also be ingested to Enterspeed. Using the “Seed to Enterspeed”-functionality also ingests all Media items.

This makes it possible to access the media’s meta information, for instance, width, height, type, etc.  

Improvement Extend meta-data for Umbraco sources 📄

Our Umbraco integration already includes a default property service, that maps all properties (including some meta-data) that are present on all data sources.

Some might need to extend the meta-data, for instance, to include site settings or domain name data. For this, we have created a Custom Property Service, which makes it easy to extend the meta-data on sources.

You can find more information about this in our documentation.

• Umbraco V10 - Enterspeed property service
• Umbraco V9 - Enterspeed property service
• Umbraco V8 - Enterspeed property service

...that was some sweet Umbraco updates 🙌

You may be setting with a slight frown on your face thinking “What about me? I don’t use Umbraco – doesn’t Santa have anything for me?”.

Don’t worry, kiddo, of course, we didn’t forget about you 🎁

feature Dark mode 🌚

That’s right, you can put your sunglasses away – we’ve added Dark mode support in the Enterspeed app.

Dark mode is properly one of the most requested features in software – and we get it. Once you have switched your IDE from the default light theme to a dark theme, there’s no going back.

💡 Tip: Our code editor inside the Enterspeed app supports themes, meaning you can keep the light theme and include a dark-mode editor. You’ll find the theme switcher at the bottom of the editor.

Improvement Enterspeed demos 🖥️

Instead of having multiple different repos for our demos, we have now moved them all to a single monorepo.

While doing this, we have also added demo content to each individual demo folder, making it easier to find and use.

We now have 11 different demos showing how to use Enterspeed:

• Astro
• Gatsby
• Next.js
• Nuxt 3
• Remix
• SvelteKit
• Umbraco & Next.js
• Umbraco & Nuxt 3
• Umbraco & Next.js & Krabs.js (Multisite)
• Umbraco & Storybook
• Vanilla JS & Google Sheets

You can find our demo repo on Github: https://github.com/enterspeedhq/enterspeed-demos

fix Fixes and tweaks 🛠️

• Upgraded Enterspeed Delivery .NET SDK to .NET 6.0
• Added originParentId to source entity API response
• Added FAQ section to the documentation: https://docs.enterspeed.com/faq
• Added option to reprocess single source entity
• Made Source Group alias editable doing creation
• Added redirect to tenant after the user accepts a tenant invitation
• Added support for dash and underscore in partial schema alias
• Fixed bug where schemas couldn’t be published if it had a trashed source
• Fixed wrong text on delete environment modal
• Fixed wrong description in documentation, saying sourceEntityType is required in $lookup, which it isn’t.   

Until next time 👋

We know, we know. It's been a long, long time 🎵

But don't worry, unlike the late Kitty Kallen, we won't ask you to kiss us once nor twice. 

Instead, we'll introduce you to one of our biggest updates yet. You see, we haven't just been slacking off this whole time. No sir/ma'am, we have been busy working on our new bulk schema deployment, among many other things.

But before we can talk about this, we need to dive into our new source group concept - because, just like string theory, it's all connected 🧵. 

feature Source groups 👪

We have introduced a new layer to the data sources called source groups. Adding the source group concept was a necessity to make our new bulk deploy flow as simple to use as possible. 

A source group wraps around your data sources and bundles them into a single group. This helps you to keep better track of your sources.

Most developers work with multiple environments (meaning multiple data sources) when developing a project, for example, Production, Staging, and Development.

Having all these data sources grouped together makes it easier to manage, and helps avoid mistakes, for instance, accidentally adding one source to multiple environments.

Source groups now also make it possible to use actions across multiple sources 👏.

When using source groups, the new schema field, triggers, will be replacing the old sourceEntityTypes schema field.

deprecation sourceEntityTypes schema field ⚰️

Alas, it's time to say goodbye to the schema field sourceEntityTypes. 

When using the new source groups, it's no longer possible to use sourceEntityTypes. It will now be replaced with the new schema field: triggers.

The triggers-field is an object containing your source group(s) that contains an array of source entity types. 

feature Bulk deploy  📦📦📦🚀

Enough beating around the bush. Let's get into the main star of the show - the new bulk deploy feature 🌟.

Deploying changes, keeping track of changes, and mirroring environments just got ten times easier.

Instead of having to go through multiple schemas and releasing one by one, you are now able to do it in one go.

Not only does it save you time - but it also minimizes the risk of errors, since you get a complete overview of the current versions and versions which are going to be deployed. 

Moreover, since schemas can be interconnected, the option to deploy simultaneously reduces risks even further.

Instead of having a deploy button on the "single schema view" a "deploy changes"-button has now been added to the header.

Clicking this opens a pane, which allows you to select which environment you wish to deploy your changes to.

A list of all schema changes is shown, alongside the currently deployed version, which version will be deployed, and the state of the schema (added, updated, deleted, unchanged).

You can also choose to exclude a schema from deployment, deploy another version or simply unpublish it.

If you wish to unpublish or change a version of a schema that doesn't have any current changes, you can click "Load unchanged versions" to append the table with the rest of your schemas.

Last but certainly not least, a much-requested feature. You now have the option to copy versions from another environment - meaning mirroring an environment.

This is really useful when testing things out on the Development environment, which you wish to copy to the Production environment.

To do this, simply select the environment you wish to use the versions from in the "Use versions from different environment"-select and click apply.

Afterward, click Deploy X changes and confirm. After the schemas have been validated they are now deployed to your environment.

feature Dynamic mapping ⚡

Now that your head is almost filled to the limit with pure awesomeness, allow us to introduce a feature that will make your head explode.

One of the powerful things about Enterspeed is the option to model and transform your content however you like. 

However, there are times when your current content model matches your needs, and transformation isn't necessary. 

This is where dynamic mapping shines, which is done by using our dynamic property type.

Say you have a product where you want all of its properties (title, image, description, price, stock, etc.). Instead of mapping all of these single properties out, you simply type:

"product": {

 "*": "p"

}

Now all properties from your source entity can be accessed using p.thePropertyName.

Say you only want the features? No problem, you just define this by appending "p." with the property name like so:

"features": {

 "*": "p.features"

} 

You can read more about how it works in our documentation under Path selector.

feature Sitecore integrations 🔌

We have expanded our integrations list with two new integrations for Sitecore - version 8 and version 9. 

These integrations let you automatically push data from your Sitecore solution into your Enterspeed-project.

Furthermore, we have added in-depth tutorials for both integrations, which you can find in our documentation under integrations.

Improvement Schema snippets in docs ✂

Just like googling is a core skill for all developers, so is copy-pasting code snippets (thank you, Stack Overflow).

We're all on board with this, which is why we have created a schema snippets section in our documentation.

Happy copy-pasting🙌

Improvement Editor Command Palette 🎨

We use the Monico editor for our schema editor. If it feels familiar, it may be because it's the same editor that powers VS Code. 

This also means it comes built-in with a ton of handful features - including the command palette. 

To run a command, simply press F1 or click the "play"-button on the right side of the editor to open the menu.

Improvement Editor band 🩹

We have added a "band" to the bottom of the schema editor. We have moved Save-status, Autosave-option, Theme-selection, and the WordWrap-option to this "band".

All schema errors will also be shown here, in the bottom left corner.

Improvement Warnings in "test run" ⚠

When doing a "dry run" (testing your schemas on source entities), we have now included schema warnings, alongside schema errors.

This can help you spot redundant code, for instance, referenced source groups that are no longer in use.

fixFixes and tweaks 🛠️

• The Umbraco V9 integration now supports overwriting the job handlers responsible for ingesting data to Enterspeed. You can read more about it here.
• More descriptive text has been added to the API reference.
• When creating an environment client, you will now be asked to also add a domain. If no domains are added, a warning will be shown.
• Removed checkmark-bug from the "load more"-button on initial load.
• Our Next.js-demo now supports Preview-mode.
• The "click outside to close"-functionality has been removed from all modal windows to avoid accidental closes.
• A schema action menu has been added to the "single schema view", allowing renaming, deletion, and navigating between versions.
• Warning added on "Create source group" when trying to create without saving new sources.
• Deprecated "own shortcuts" (mainly used for navigation between pages) to not conflict with editor shortcuts.
• Filters from source entities / generated views are now removed until a source/environment is selected.

One of the core pillars of Enterspeed is the ability to get your data into our Headless Hub. It's quick and easy to do, using one of our integrations or our ingest API.

But here at Enterspeed, the developer is king 👑, so we want to make it even easier and quicker to ingest data. 

So sit back and let us blow ya mind, like were we Eve & Gwen Stefani.

feature Ingest API V2 📤

In version 1 of our Ingest API, you had to specify the type of all properties, which looked something like this.

In version 2 of our Ingest API we have made this much more simple, by automatically detecting types based on the data itself. This means that the code above can be reduced to this:

Quite the improvement, huh? But wait, there's more (As the late Billy Mays would have put it). 

When ingesting data into Enterspeed, a requirement is that you specify originId and type. You can also pass along URL, redirects, etc.

However, not everybody is able to manipulate the data to also include these properties, which is why we give you the option to ingest RAW data in and specify the type, URL, redirects, etc. in the headers, reducing the above code to this:

Mind = blown 🤯

You can read more about it in our documentation here: Enterspeed Ingest API.

💡 V1 of the Ingest API is still supported, however, we recommend you use the new V2.

feature Umbraco integration upgrade - preview changes 🔎

As a company building a high-performing headless hub, you may be shocked when we say: Headless is the future.

But, working in a headless environment isn't always a cakewalk. Tasks like previewing content before publishing it can sometimes be cumbersome, to say the least.

BUT NOT ANYMORE, BABY!! 🎉🎊

Ahem, sorry I got carried away. I mean... This isn't the case anymore.

Our updated Umbraco-integration (which is right around the corner) now enables preview mode!

Yes, you read that right. You're now able to insert a preview API key under configuration.

To get the Preview API key, create a new data source in Enterspeed that stores your preview data. This enables you to setup an internal site / URL for your content creators, which fetches the preview data.

Now, every time one of your creators saves new content, they can view it on their internal site / URL. When they're ready to share it with the world, they simply hit publish and it will be available to the world 🌍.

feature See when source entities have been updated 🕐

When working with your source entities it can be useful to see when the data was last updated - especially if you're trying to debug something (e.g. a custom script for ingesting data).

We've added the "Updated"-column in the source entities table, which tells you when the data was last updated.

feature Avoid losing unsaved schema changes 😱

Losing unsaved changes. Just saying the words can trigger any developer's anxiety. 

It's so frustrating that even pounding the instant "Nooooooooooooooo"-button multiple times won't make you feel any better.

Close your eyes, take a deep breath, and calm yourself again. We're not going to let this happen to you. Not on our watch.

If you have unsaved changes in your schema and try to navigate away, you'll now be met with a warning:

Still got anxiety? Here's a link to "The Best of ENYA | Non-Stop Playlist". Take a break and come back when you're ready. We'll be here.

feature Duplicate schema 👯

When working with schemas, you may want to reuse some of the code from another schema. No problem!

You can now duplicate a schema by clicking on the settings menu (three dots) in the schema table and selecting "Duplicate". Easy 🙌

feature Chat support 💬

We'll be there for you 🎵

We have implemented chat support in both our app and on Enterspeed.com, so it's easy for you to get help if you should get stuck or have any questions. 

Improvement New visual identity 🎨

Just like Maria from West Side Story, you can say we "feel pretty, oh so pretty... 🎵".

You may have noticed our new visual identity in both our App, documentation, sign in, and website (Enterspeed.com)💅

Improvement Improved schema reference documentation 📄

"Did you read the docs?" asking a developer this question is equivalent to a tech supporter asking "Have you tried turning it off and on again?". 🤔

There's a reason for this. Just like rebooting your device often can fix bugs, reading the documentation for a piece of software can save you so much time on debugging. As the quite sarcastic quote goes:

"6 hours of debugging can save you 5 minutes of reading documentation".

To improve the developer experience, we have moved the "Schema reference"-page to the top menu and improved the documentation even further.

You'll find the Schema reference right here.

Improvement Get help text throughout the app 🆘

Throughout the Enterspeed-app you'll encounter our help-icon (?). Here you'll find a short explanation of what the specific area/element is used for. 

Hover your cursor over the icon to get a tooltip containing supporting text.

Improvement Autofilling schema alias ✍️

Nothing is more annoying than having to repeat things (every parent especially knows this feeling - "...for the 36. time, no! You can't have ice cream instead of dinner! God!").

To make your life a little bit easier (and save your precious mental energy for when your kids are being annoying) the schema alias now gets auto-filled. 

If you want to rename your schema alias to something else, you simply click on the padlock icon. 

Improvement Refresh button on source entity 🔄

If you're working on your data source (e.g. the CMS you've connected) simultaneously while viewing the specific data in Enterspeed, you may need to refresh this view. 

Instead of refreshing the browser, you can now simply click on the refresh button which refreshes the source entity. 

Improvement Added test button on source entity single view (pane view) 🧪

When designing your schema, it can be really helpful having your source entity next to you. This is why we have the "Source entities"-pane available directly in the schema editor.

Here you are also able to test your schema with a specific source entity. 

Before this could only be done via the table view, listing all source entities. Now the test button is also available in the "source entity single view", meaning you won't have to navigate back and forth.

fixFixes and tweaks 🛠️

• New and improved onboarding experience when creating an account.
• Added "environment client" and "domains" to the getting started checklist.
• The top property in $lookup now supports both number and string format.
• Schema alias is now visible in the schema editor.
• Creating a schema now automatically redirects you to the schema afterward.

You're a busy person, we get it. Just like the great Freddie Mercury, you don't have no time for no monkey business.

Don't worry fam, we got you! Introducing the Enterspeed Starter template.

feature Enterspeed Starter template ▶️

Nothing is more painful than needing to do a lot of manual work in order to test something. Okay, some things might be more painful, but you get the point.

Testing things should be quick and easy, which is why we have made it extremely easy (and quick) to start testing out Enterspeed. 

When creating a new tenant, you now have the option to use the Enterspeed Starter template.

Selecting this automatically set up and imports:

• Environment 
• Environment client
• Domain
• Data source
• Schemas
• Partial schemas
• Source entities

This means you can start transforming data right away, and/or try to fetch it to your frontend project.

You can see in the video below how easy it is!

feature Nuxt3 Demo project

We are proud to showcase yet another demo project - this time using Nuxt3. 

To give you an idea of how Enterspeed can be implemented in a frontend project, we have made a Nuxt3 demo site, similar to our Next.js demo site.

🏊 Dive into our public Github repo to see exactly how we made the demo.

feature Algolia integration (Preview mode)

We've been tweaking and tinkering, and are ready with a new, extremely powerful integration: Algolia.

If you're not familiar with Algolia, it is one of the most popular "Site Search & Discovery APIs".

Our new integration makes it possible to push your Enterspeed data up to Algolia, so you're able to quickly implement search in your application.

The integration is currently in preview mode, meaning you'll have to drop us an email if you want to try it out.

feature Routes on generated views

You can now see routes on generated views. Preeeeetty cool 😎 

feature Action to delete all source entities

When testing out ingesting data to Enterspeed, it can sometimes be useful to remove all previously ingested data. 

We've made this really simple by adding a "Delete all"-button in the Source entities table. You can also do this by navigating to Data sources, clicking the settings button next to the data source, and selecting "Delete all entities".

feature Tutorial videos 🎞️

To make it even easier to get started with Enterspeed, we've made 6 new tutorial videos that demonstrate some of the main topics in Enterspeed.

The tutorials are:

• Setting up a tenant in Enterspeed
• Designing a schema with Enterspeed
• Ingesting data into Enterspeed
• Enterspeed starter template
• Seeding data from Umbraco to Enterspeed
• Tagging in Umbraco (Filter by tag in Enterspeed)

So grab some popcorns and get binge-watching 🍿

feature Onboarding checklist

To give you a better understanding of "the steps you need to complete", we've included a checklist in the overview.

Improvement Moved alias/viewHandle from partial schema

To simplify the partial schemas, we've moved the alias/viewHandle out from the JSON schema. Instead, it's now provided during new partial creation.

Improvement Generated views filters are now searchable 🔎

If you have a large application, the generated views table can grow quite big. 

To make it easier to find exactly the generated view you need, we've made all the filters searchable. 

Improvement API keys are now hidden by default

As the old saying goes: "Don't be dumb as a tree 🌳, always, ALWAYS, hide your API key 🔑".

Okay, to be honest, I just made that saying up, but nonetheless the point remains valid. 

Therefore, all API keys inside Enterspeed are now blurred by default. 

fixFixes and tweaks 🛠️

• The email verification process on the "sign up"-page has been made smoother.
• When switching between generated views, the data are now re-fetched.
• Tables rows are now clickable for items that contain a single view (e.g. the schemas table).
• After schema deployment autosave sometimes got stuck, this is now fixed.
• After bulk deletion, pagination wasn't updated, this is now fixed.

Until next time 👋

Pssst... This post is a part of a new series we call EPU - Enterspeed Products Updates. 

To give you a better idea of all the improvements, features - and let's face it - bug fixes we roll out, we've decided to try out a new format. 

feature Generated views 👁️

We're excited to announce our new feature, Generated views, which lets you see the views your schemas generate from your data sources.

It's not quite a whole new world, but it is shining, shimmering, splendid 🎵

Generated views let you see exactly how your content will be delivered to your front-end. 

This makes it much easier when designing and debugging your schemas.

feature Schema cheat sheet 🤫

Speaking of making schema design easier. We've implemented a schema cheat sheet in the UI.

The cheat sheet lets you quickly see the references available alongside a short explanation. 

You can find the cheat sheet button in the schema editor, next to the "add to favorites"-button (heart icon).

feature Filter on partial schemas

We already have it on schemas, but now you can also get all your filtering needs satisfied on partial schemas. Hooray 🎉

Improvement Restructuring of the docs

To make our docs more simple, we have restructured some of the content and added top-level navigation.

Improvement API now included in docs

Speak of the devil. In the top-level navigation of our docs, you'll now find a link to our API, which has been embedded directly in the docs.

Improvement New layout for the login- and signup page

Don't be frightened - it's still us. We've just put on our finest, Sunday clothes 👗

fix Fixes and tweaks 🛠️

"Developers, developers, developers!"

We're almost as excited for developers as Steve Ballmer (no one can quite reach his level).

Since we're so excited for developers, we want to make the developer experience as great as possible.

One way we have done this is by reducing the amount of code needed when writing properties. We've introduced shorthands!

Before when you needed to output a string, you had to write something like this:

And, if you're inserting a string, you can simply write.

And... Since properties is a pain to write every time, you can now simply write p.

Awesome stuff 🙌

To avoid confusion and to keep consistency, we are also replacing (though still supported) the old viewHandle and view reference and replacing them with alias.

The old way:

The new way:

Hi there 👋

As part of improving the user experience, we've decided to revamp our UI. We're excited to show you our new layout. 

As we started planning and adding more features to our app, we quickly found our old UI lacking some elements.

One thing led to another and we decided to give our UI a makeover. 💅

Our focus is always to provide the best user experience, which is a continuous process of improvement.

In addition to a lot of layout changes, we also decided to rethink the navigation and content structure.

You'll find the elements which are most frequently used in the Home section, while elements which isn't used that much in the day-to-day work now have been moved to a new section called Admin.

The new UI also gives us a lot of space to add new exciting features, which you'll see before long.