Using Open Source Cedar to Write and Enforce Custom Authorization Policies

Cedar is an open source language and software development kit (SDK) for writing and enforcing authorization policies for your applications. You can use Cedar to control access to resources such as photos in a photo-sharing app, compute nodes in a micro-services cluster, or components in a workflow automation system. You specify fine-grained permissions as Cedar policies, and your application authorizes access requests by calling the Cedar SDK’s authorization engine. Cedar has a simple and expressive syntax that supports common authorization paradigms, including both role-based access control (RBAC) and attribute-based access control (ABAC). Because Cedar policies are separate from application code, they can be independently authored, analyzed, and audited, and even shared among multiple applications.

In this blog post, we introduce Cedar and the SDK using an example application, TinyTodo, whose users and teams can organize, track, and share their todo lists. We present examples of TinyTodo permissions as Cedar policies and how TinyTodo uses the Cedar authorization engine to ensure that only intended users are granted access. A more detailed version of this post is included with the TinyTodo code.


TinyTodo allows individuals, called Users, and groups, called Teams, to organize, track, and share their todo lists. Users create Lists which they can populate with tasks. As tasks are completed, they can be checked off the list.

TinyTodo Permissions

We don’t want to allow TinyTodo users to see or make changes to just any task list. TinyTodo uses Cedar to control who has access to what. A List‘s creator, called its owner, can share the list with other Users or Teams. Owners can share lists in two different modes: reader and editor. A reader can get details of a List and the tasks inside it. An editor can do those things as well, but may also add new tasks, as well as edit, (un)check, and remove existing tasks.

We specify and enforce these access permissions using Cedar. Here is one of TinyTodo’s Cedar policies.

// policy 1: A User can perform any action on a List they own
permit(principal, action, resource)
when {
    resource has owner && resource.owner == principal

This policy states that any principal (a TinyTodo User) can perform any action on any resource (a TinyTodoList) as long as the resource has an owner attribute that matches the requesting principal.

Here’s another TinyTodo Cedar policy.

// policy 2: A User can see a List if they are either a reader or editor
permit (
    action == Action::”GetList”,
when {
    principal in resource.readers || principal in resource.editors

This policy states that any principal can read the contents of a task list (Action::”GetList”) so long as they are in either the list’s readers group, or its editors group.

Cedar’s authorizer enforces default deny: A request is authorized only if a specific permit policy grants it.

The full set of policies can be found in the file TinyTodo file policies.cedar (discussed below). To learn more about Cedar’s syntax and capabilities, check out the Cedar online tutorial at

Building TinyTodo

To build TinyTodo you need to install Rust and Python3, and the Python3 requests module. Download and build the TinyTodo code by doing the following:

> git clone
…downloading messages here
> cd tinytodo
> cargo build
…build messages here

The cargo build command will automatically download and build the Cedar Rust packages cedar-policy-core, cedar-policy-validator, and others, from Rust’s standard package registry,, and build the TinyTodo server, tiny-todo-server. The TinyTodo CLI is a Python script,, which interacts with the server. The basic architecture is shown in Figure 1.

Figure 1: TinyTodo application architecture

Running TinyTodo

Let’s run TinyTodo. To begin, we start the server, assume the identity of user andrew, create a new todo list called Cedar blog post, add two tasks to that list, and then complete one of the tasks.

> python -i
>>> start_server()
TinyTodo server started on port 8080
>>> set_user(andrew)
User is now andrew
>>> get_lists()
No lists for andrew
>>> create_list(“Cedar blog post”)
Created list ID 0
>>> get_list(0)
=== Cedar blog post ===
List ID: 0
Owner: User::”andrew”
>>> create_task(0,”Draft the post”)
Created task on list ID 0
>>> create_task(0,”Revise and polish”)
Created task on list ID 0
>>> get_list(0)
=== Cedar blog post ===
List ID: 0
Owner: User::”andrew”
1. [ ] Draft the post
2. [ ] Revise and polish
>>> toggle_task(0,1)
Toggled task on list ID 0
>>> get_list(0)
=== Cedar blog post ===
List ID: 0
Owner: User::”andrew”
1. [X] Draft the post
2. [ ] Revise and polish

Figure 2: Users and Teams in TinyTodo

The get_list, create_task, and toggle_task commands are all authorized by the Cedar Policy 1 we saw above: since andrew is the owner of List ID 0, he is allowed to carry out any action on it.

Now, continuing as user andrew, we share the list with team interns as a reader. TinyTodo is configured so that the relationship between users and teams is as shown in Figure 2. We switch the user identity to aaron, list the tasks, and attempt to complete another task, but the attempt is denied because aaronis only allowed to view the list (since he’s a member of interns) not edit it. Finally, we switch to user kesha and attempt to view the list, but the attempt is not allowed (interns is a member of temp, but not the reverse).

>>> share_list(0,interns,read_only=True)
Shared list ID 0 with interns as reader
>>> set_user(aaron)
User is now aaron
>>> get_list(0)
=== Cedar blog post ===
List ID: 0
Owner: User::”andrew”
1. [X] Draft the post
2. [ ] Revise and polish
>>> toggle_task(0,2)
Access denied. User aaron is not authorized to Toggle Task on [0, 2]
>>> set_user(kesha)
User is now kesha
>>> get_list(0)
Access denied. User kesha is not authorized to Get List on [0]
>>> stop_server()
TinyTodo server stopped on port 8080

Here, aaron‘s get_list command is authorized by the Cedar Policy 2 we saw above, since aaron is a member of the Team interns, which andrew made a reader of List 0. aaron‘s toggle_task and kesha‘s get_list commands are both denied because no specific policy exists that authorizes them.

Extending TinyTodo’s Policies with Administrator Privileges

We can change the policies with no updates to the application code because they are defined and maintained independently. To see this, add the following policy to the end of the policies.cedar file:

principal in Team::”admin”,
resource in Application::”TinyTodo”);

This policy states that any user who is a member of Team::”Admin” is able to carry out any action on any List (all of which are part of the Application::”TinyTodo” group). Since user emina is defined to be a member of Team::”Admin” (see Figure 2), if we restart TinyTodo to use this new policy, we can see emina is able to view and edit any list:

> python -i
>>> start_server()
=== TinyTodo started on port 8080
>>> set_user(andrew)
User is now andrew
>>> create_list(“Cedar blog post”)
Created list ID 0
>>> set_user(emina)
User is now emina
>>> get_list(0)
=== Cedar blog post ===
List ID: 0
Owner: User::”andrew”
>>> delete_list(0)
List Deleted
>>> stop_server()
TinyTodo server stopped on port 8080

Enforcing access requests

When the TinyTodo server receives a command from the client, such as get_list or toggle_task, it checks to see if that command is allowed by invoking the Cedar authorization engine. To do so, it translates the command information into a Cedar request and passes it with relevant data to the Cedar authorization engine, which either allows or denies the request.

Here’s what that looks like in the server code, written in Rust. Each command has a corresponding handler, and that handler first calls the function self.is_authorized to authorize the request before continuing with the command logic. Here’s what that function looks like:

pub fn is_authorized(
principal: impl AsRef<EntityUid>,
action: impl AsRef<EntityUid>,
resource: impl AsRef<EntityUid>,
) -> Result<()> {
let es = self.entities.as_entities();
let q = Request::new(
info!(“is_authorized request: …”);
let resp = self.authorizer.is_authorized(&q, &self.policies, &es);
info!(“Auth response: {:?}”, resp);
match resp.decision() {
Decision::Allow => Ok(()),
Decision::Deny => Err(Error::AuthDenied(resp.diagnostics().clone())),

The Cedar authorization engine is stored in the variable self.authorizer and is invoked via the call self.authorizer.is_authorized(&q, &self.policies, &es). The first argument is the access request &q — can the principal perform action on resource with an empty context? An example from our sample run above is whether User::”kesha” can perform action Action::”GetList” on resource List::”0″. (The notation Type::”id” used here is of a Cedar entity UID, which has Rust type cedar_policy::EntityUid in the code.) The second argument is the set of Cedar policies &self.policies the engine will consult when deciding the request; these were read in by the server when it started up. The last argument &es is the set of entities the engine will consider when consulting the policies. These are data objects that represent TinyTodo’s Users, Teams, and Lists, to which the policies may refer. The Cedar authorizer returns a decision: If Decision::Allow then the TinyTodo command can proceed; if Decision::Deny then the server returns that access is denied. The request and its outcome are logged by the calls to info!(…).

Learn More

We are just getting started with TinyTodo, and we have only seen some of what the Cedar SDK can do. You can find a full tutorial in in the tinytodo source code directory which explains (1) the full set of TinyTodo Cedar policies; (2) information about TinyTodo’s Cedar data model, i.e., how TinyTodo stores information about users, teams, lists and tasks as Cedar entities; (3) how we specify the expected data model and structure of TinyTodo access requests as a Cedar schema, and use the Cedar SDK’s validator to ensure that policies conform to the schema; and (4) challenge problems for extending TinyTodo to be even more full featured.

Cedar and Open Source

Cedar is the authorization policy language used by customers of the Amazon Verified Permissions and AWS Verified Access managed services. With the release of the Cedar SDK on GitHub, we provide transparency into Cedar’s development, invite community contributions, and hope to build trust in Cedar’s security.

All of Cedar’s code is available at Check out the roadmap and issues list on the site to see where it is going and how you could contribute. We welcome submissions of issues and feature requests via GitHub issues. We built the core Cedar SDK components (for example, the authorizer) using a new process called verification-guided development in order to provide extra assurance that they are safe and secure. To contribute to these components, you can submit a “request for comments” and engage with the core team to get your change approved.

To learn more, feel free to submit questions, comments, and suggestions via the public Cedar Slack workspace, You can also complete the online Cedar tutorial and play with it via the language playground at

Flatlogic Admin Templates banner

jQuery 3.6.2 Released!

You probably weren’t expecting another release so soon, but jQuery 3.6.2 has arrived! The main impetus for this release was the introduction of some new selectors in Chrome. More on that below.

As usual, the release is available on our cdn and the npm package manager. Other third party CDNs will probably have it soon as well, but remember that we don’t control their release schedules and they will need some time. Here are the highlights for jQuery 3.6.2.

undefined and whitespace-only CSS variables

jQuery 3.6.1 introduced a minor regression where attempting to retrieve a value for a custom CSS property that didn’t exist (i.e. $elem.css(“–custom”)) threw an error instead of returning undefined. This has been fixed in 3.6.2. Related to that, we also made sure that whitespace-only values return the same thing across all browsers. The spec requires that CSS variable values be trimmed, but browsers are inconsistent in their trimming. We now return undefined for whitespace-only values to make it consistent with older jQuery and across the different browsers.

.contains() with <template>

An issue was recently reported that showed that a <template>‘s document had its documentElement property set to null, in compliance with the spec. While it made sense semantically for a template to not yet be tied to a document, it made for an unusual case, specifically in jQuery.contains() and any methods relying on it. That included manipulation and selector methods. Fortunately, the fix was simple.

It wasn’t Ralph that broke the internet

The internet experienced a bit of a rumble when Chrome recently introduced some new selectors, the most pertinent of which being :has(). It was a welcome addition, and one celebrated by the jQuery team, but a change to the spec meant that :has() used what’s called “forgiving parsing”. Essentially, even if the arguments for :has() were invalid, the browser returned no results instead of throwing an error. That was problematic in cases where :has() contained another jQuery selector extension (e.g. :has(:contains(“Item”))) or contained itself (:has(div:has(a))). Sizzle relied on errors like that to know when to trust native querySelectorAll and when to run the selector through Sizzle. Selectors that used to work were broken in all jQuery versions dating back to the earliest jQuery versions.

And yet, this little drama didn’t last long. The Chrome team quickly implemented a workaround to fix previous jQuery versions in the vast majority of cases. Safari handled their implementation of :has() a little differently and didn’t have the same problem. But, there’s still an important issue open to determine how to address this in the CSS spec itself. The CSSWG has since resolved the issue.

jQuery has taken steps to ensure that any forgiving parsing doesn’t break future jQuery versions, even if previous jQuery versions would still be affected.


We do not expect compatibility issues when upgrading from a jQuery 3.0+ version. To upgrade, have a look at the new 3.5 Upgrade Guide. If you haven’t yet upgraded to jQuery 3+, first have a look at the 3.0 Upgrade Guide.

The jQuery Migrate plugin will help you to identify compatibility issues in your code. Please try out this new release and let us know about any issues you experienced.

If you can’t yet upgrade to 3.5+, Daniel Ruf has kindly provided patches for previous jQuery versions.


You can get the files from the jQuery CDN, or link to them directly:

You can also get this release from npm:

npm install [email protected]

Slim build

Sometimes you don’t need ajax, or you prefer to use one of the many standalone libraries that focus on ajax requests. And often it is simpler to use a combination of CSS and class manipulation for web animations. Along with the regular version of jQuery that includes the ajax and effects modules, we’ve released a “slim” version that excludes these modules. The size of jQuery is very rarely a load performance concern these days, but the slim build is about 6k gzipped bytes smaller than the regular version. These files are also available in the npm package and on the CDN:

These updates are already available as the current versions on npm and Bower. Information on all the ways to get jQuery is available at Public CDNs receive their copies today, please give them a few days to post the files. If you’re anxious to get a quick start, use the files on our CDN until they have a chance to update.


Thank you to all of you who participated in this release by submitting patches, reporting bugs, or testing, including sashashura, Anders Kaseorg, Michal Golebiowski-Owczarek, and the whole jQuery team.


Full changelog: 3.6.2


Return undefined for whitespace-only CSS variable values (#5120) (8bea1dec)
Don’t trim whitespace of undefined custom property (#5105, c0db6d70)


Manipulation: Fix DOM manip within template contents (#5147, 5318e311)
Update Sizzle from 2.3.7 to 2.3.8 (#5147, a1b7ae3b)
Update Sizzle from 2.3.6 to 2.3.7 (#5098, ee0fec05)


Remove a workaround for a Firefox XML parsing issue (965391ab)
Make Ajax tests pass in iOS 9 (d051e0e3)

Flatlogic Admin Templates banner

Next.js vs React: Which One to Choose for Your App?

The burning question today is What’s better: React or Next.js? Let’s have a look closely at both, compare them and see the difference between library and framework. In the React world, Next.js is one of the most popular frameworks for “hitting the ground running.”

What is Next.js?

Next.js is an open-source JavaScript framework for developing fast, lightweight, and easy-to-use web applications and static websites (one-pages) using React. Next.js was created by Vercel in 2016. Next.js requires Node.js and can be initialized using npm. There are a lot of reasons why Next.js has such a strong reputation in the world of application development. They are known for being reliable as they offer image optimization, internationalization, zero-config, Next.js analytics, hybrid: SSR and SGG, fast refresh, API routes, TypeScript support, file-system routing, code-splitting and bundling, incremental static regeneration, and built-in CSS support, etc.

Next.js includes all the features needed to build an application. Moreover, the documentation is excellent and it is becoming very popular among developers for frontend development.Here are the most popular platforms and apps of Next.js:, TikTok, Hulu, Binance, and many others that involve a massive number of users engaging with complex data influxes.

What is React?

React is an efficient, declarative and flexible JavaScript library for building interactive UI, inspired by xHP, the HTML component library for PHP. React was created by Facebook in 2011 and then open-sourced in 2013.React is used to create dynamic, mobile apps, one-pages, visualization tools, and dashboards. Here are some of the most popular platforms and apps created with React: Facebook, Netflix, Atlassian, Airbnb, Dropbox, Reddit, etc.

Next.js vs React

Even in a sea of JavaScript frameworks and libraries, React and NextJS stand out. React is the most popular JavaScript library for frontend developers. NextJS, although smaller than React, has grown continuously over the years and is well on its way to becoming the most-used JavaScript framework. So, let’s compare React and Next.js. React – is a JavaScript library for building UI. Next.js – is the React framework. NextJS is used on top of React, extending its features and optimizing the development process: React doesn’t even have to work with NextJS, but NextJS uses React to deploy applications.

React has a special framework – Create React App, an application used to create React projects and includes tools such as Babel, Webpack, and ESlint. Next.js is a React-based framework that allows you to build applications with server-side rendering. React is still the core of the application, but the structure and navigation mechanisms (architecture) – are defined by Next.js. The difference between a framework and a library is that a framework has more features and focuses on several aspects of development, and gives you rules and guidelines for writing code and structuring files.

React & Create React App (CPA)

Server-Side Rendering (SSR)
Supports different types of SSR.
– Static generation: obtaining data at build time. Best suited for use cases such as blogs or static websites.
– Server-side rendering: sampling data and rendering for each request. May be needed when you need to serve different views to different users.
Doesn’t support SSR out of the box. 
However, you can still set it up. 
It just takes more effort to configure SSR with your preferred server and configuration.

Almost everything is configurable
If you check the example NextJs templates, you can see files like 
babelrc, jest.config, eslintrc etc. that you can configure.
Doesn’t leave you much space to configure it. 
Configurations, such as webpack config, cannot be changed unless you do not deviate from the usual CRA path (eject, rescripts, rewired, craco). 
You should use what is configured in 
react-scripts, which is the core of CRA.

Well maintained. Release regular updates.
Very sensitive. 
If you keep up with updates of CRA releases, it is not difficult to maintain.


Supports typescript out of the box. 
Configurations for TypeScript:
touch tsconfig.json

Supports. You can initialize the CRA app with typescript like this:
npx create-react-app my-app —template typescript

Hooks Support

Redux Support

Incredibly fast apps thanks to static sites and server-side rendering.
Decent, but the lack of code splitting results in poor performance.

Tiny, but friendly
Both huge and friendly

Support static exports, and pre-rendering, and has a lot of features, for example, automatic building size optimization, fast development compilation and preview mode.
Easily extensible, can include routing as well as management patterns with libraries.

Talent pool

Easy to learn

Development costs

Which one is better?

It’s hard to say that one is better than the other. Remember, React.js is a JS library – a set of tools you can use to build UI – and Next.js is a framework – the blueprints and rules you need to build an entire app – based on React so it’s not a pick this one instead of the other situation.

Use React when:

You need a highly dynamic routing
You’re already familiar with JSX
You need offline support

Use Next.js when:

You need an all-inclusive framework
You require backend API endpoints
You need server-side rendering

What do React vs Next.js projects look like


You can get started with React by installing Node.js on your machine and running npx create-react-app react-app. This will create a basic project structure with the src/App.js file as the entry point for the application. You’ll also have a public folder where you can store assets, and the initial scaffold looks like this:


With Next.js, you can get started by running npx create-next-app next-app. This will scaffold out a project that already has a pages folder for the pages or routes and a public directory that hosts your assets. The initial scaffold looks like this:

The files in the pages directory relate to routes in your application. The public directory stores your static files or images that you want to serve and can be directly accessed – no need to use require or other React traditional methods to import images into components.

Building Next.js and React projects with Flatlogic

The Flatlogic platform is a great way to bridge the gap between developing your applications. Applications usually use the same elements and components, when using the same technologies. The main thing that distinguishes them on a technical level is the database schema, which implements different data processing and storage mechanisms. The Flatlogic Platform allows you to create applications by combining parts and creating only those that need to be unique. Here you can see how to use the Flatlogic Platform to create Next.js, React applications, and other options for creating CRUD applications on the React. To generate your Next.js or React application, tap here and let’s go.

Step 1

Name your project and choose the tech stack: React as frontend and No-backend as backend.

Step 2

Choose the Starter Kit. Here you need to decide which starter kit is best for your project: Next.js or Create React App.

Next, you need to connect your GitHub repository and check the stack and starter kit and Finish the creation process.

Then you will be redirected to the project settings where you will need to deploy your application.


React and Next.js are new and useful tools for your project, but only for certain tasks. When you choose Next.js, it offers the best solutions for server-side rendering and static website development. It also makes it easy to manage projects with a variety of tools and features.

On the other hand, React is the best choice for developing UIs for one-page applications. Being mobile and web-enabled, it works with a layer of mobile and web applications to create more appealing and intuitive ones. In a nutshell, Next.js offers various tools and features to minimize the development process while React has better resources for the frontend development of your mobile and web applications.

Suggested Articles

What is Next.js? Top 7+ Next.js Templates
Angular vs React: Which One to Choose for Your Web App
Best Ways to Deploy React Apps

The post Next.js vs React: Which One to Choose for Your App? appeared first on Flatlogic Blog.Flatlogic Admin Templates banner

Starting a Web App in 2022 [Research]

Participate in our research and get 70% OFF discount on all Flatlogic products! We will also make the final results public.

The team of Flatlogic is carrying out a global scientific research that aims to identify modern patterns of web application creation, specifically which tools and approaches are used to start web apps in 2022. This is the world’s first research dedicated to this specific topic.

The research is based on an anonymous online survey that consists of 20 questions related to web development. If you are planning to build a web app, whether you are an experienced software engineer or have no web development skills at all, you are eligible for the survey. We strongly ask you to take the online survey! It will help the global web development audience a lot to find out more about the recent approaches to web app development.

We focus on uncovering a diverse representation of the usage of technologies, stacks, methodologies and other dev instruments used by coders that will help us and global audience to understand the patterns of the modern web app creation process.

We plan to advertise the survey to our socials and seek ways to earn responses from those who may not be frequent on our sites.

We look forward to your responses on how to build a full stack web app — and if you share this survey on social media, be sure to tag us! We are commited to share the results with you.

Ready? Steady?

The post Starting a Web App in 2022 [Research] appeared first on Flatlogic Blog.Flatlogic Admin Templates banner

Top UX Trends in 2022 for Mobile Apps

A Short Intro

Today design development doesn’t begin from a designer drawing good-looking and elegant buttons and fields on the website. It all starts with understanding how the user will navigate your application. We reverse-engineer the user’s every step and see if the path he or she follows is easy and intuitive. It matters little how many features your app has, how talented the developers are, and what well-known designer worked on the design. The cornerstone is how much your app helps achieve users’ purposes and how it meets the users’ needs. In this article, we’ll focus on the main UX trends in 2022 for Mobile Apps.

“The best products don’t focus on features, they focus on clarity.”

— Jon Bolt

So, our first prescription is to stay focused on clarity and simplicity. But UX today is not only about usability – it becomes more and more connected with other aspects of user experience, such as fun, pleasure, perception. We also want to highlight new attributes that provide good UX:

Simplicity – One of the key attributes and one of the oldest requirements for good UX. Is the experience as simple as possible tailored to user needs?

Affordance – Is the app navigation map simple, logic and easily determined at a glance?

Feedback – Apps become more complicated and multifunctional. So is it clear what is happening/ what has happened? 

Reversibility – How easily user can reverse actions and how the app recover from errors?

Accessibility – Does the application provides functionality that can be used by all intended users on any device or environment conditions? 

A Little About UX Trends in 2022 in Design

Animate All! (Just Kidding;)

Do not animate for the sake of animation. Instead, use it to make the interaction between the app and users clearer. Using animation is a controversial topic. There is a popular opinion that animation inflates UI and sends UX down the drain. And yet animations can be so much fun and so hard to resist. For one, moving objects attract people’s attention. Another and more important reason is that animation gives a familiar feeling of interacting with real-life objects: you take action and get a response.

Thanks to that, animation can solve such tasks as feedback from the app that the action is done, saving the space in the app with a multifunctional button, understanding that the action is in progress, creating an organized space with structured and dynamic blocks of information.

Feedback from the app that the action is done;

Image source:

Multifunctional button;

Image source:

Progress indicator #1;

Image source:

Progress indicator #2;

Image source:

Progress indicator #3;

Image source:

Creating an organized space with structured and dynamic blocks of information;

Image source:

You can also find an increased use of animation for companies’ logos. This is not just an attempt to stand out from competitors. It’s an additional opportunity to establish an association of what your company is about within a short time fray of logo animation. 

Image source:

We didn’t cover the full list of animation options, but that’s not the article’s focus. We want to convey the message that despite the existence of people who consider animation a redundancy, it enriches an app with great functionality, compact interface, and great user experience.  

Data-Driven Design 

It is common to build a design based on not just personal vision, but quantitative analysis as well. By implementing machine learning principles, deep analytics, and a psychological approach to user research, designers might reach a new level of interaction with users.

The «data-driven» concept implies surveys with questions, A/B testing, app analysis, behavioral research, and other tools and techniques that you can find on the internet. 

This concept is common among website developers. The quality of their work has a lot to do with visitors’ behavior which is hard to evaluate without complex tools. The data-driven analysis offers a comprehensive insight into users’ interaction with the app, the areas of the highest engagement, the information users look for, and the functionality they need. 

A designer’s vision is impossible to replace complely but we believe the growing interest in quantitative analytics will be a trend for quite some years.

A Little Bit More About Trends in UX Design

To make the user interface convenient and easy to understand, the scenarios (navigation) should be consistent and concise. Besides, tools like fonts, vibrant colors, and gradients are great for altering user perception. These elements are typically seen as UI components, not UX. But we see that in the era of an in-depth study of users’ behavior, even the color of a button affects conversion on websites and user final perception.

Easy Navigation

Life is accelerating. Time has the price, and people count it. That’s why the interface should be informative, so even a cursory glance helps understand what this app is and how it will solve problems. That also applies to navigation. A user needs to know where he or she is, where he or she can go from there, and what to do to get there.

It means that there is no place for useless, going nowhere and for nothing buttons, clickers, blocks, and other UI elements. Every element has its value for users. Look at Google’s home page – it has one input field and five buttons (try to find all)! A typical smartphone has one (if any) navigation button that carries multiple functions. And designers may use animation to create an extra simple navigation system.

Video source:

The simplification of navigation and app-user interaction is supposed to develop further and further not only in 2022. We expect big changes in the way apps communicate with users not by navigation panel, but via voice UI. There are several existing voice apps like Alexa and Siri, but they don’t offer you great and stunning functionality. However, according to Allied Market Research, the smart speaker market is estimated to $23.32 billion by 2025 with more than fivefold increase from 2017. What should we expect? Look at Jarvis, a voice assistant of Tony Stark from Marvel studio – this may become the future of the smart speaker industry.

Vibrant Colors and Gradient

Until the late 2000s gradient used for attracting attention, now it comes back to enhance flat design bringing depth and dimension to the interface. 

Image source:

The sphere of gradients is further developed with vibrant color palettes. Depending on colors used in the design you can set the mood for your app and change people’s perception of the interface. Use bold colors to create energetic feel, soft colors to create the perception of trust, pastel colors for a calming and serene experience. 

Image source:

Image source:

It matters what colors you choose. They have to be aligned with the emotional response you want to evoke in your audience, and furthermore, you need to know your audience to predict its response to the design you choose – so pay attention, please!

New Old Typography 

Typography has an alike effect on user perception as colors. Typography speaks louder than words – this statement has more than 5 million results from google search, so it can be true. But is typography really matters? 

There’s an increasing emphasis on alternative ways to communicate with users such as animation and voice UI. Still, text is the main method to convey the key idea of the app and motivate users to take action. The time when the text was displayed in a straight line, in the same size and font passed a long time ago. Now it’s time when typography comes first, the text follows.

Image source:

The main purpose of typography is to highlight ideas in the app that are of the most priority. Allow users to grab the key points as easily as possible and make their experience memorable, customize where it needs, and use simple fonts without excesses if you want to make your message clear.   

Image source:

Image source:

Be specific about what message you want to convey, why you want to convey it, and how you expect people to remember your message. The typography is not a new trend and since users have seen very aggressive and creative experiments with text presenting this field has become the combination of science and art.  


«Make your clients feel special» – this is the driving force of personalization. It starts with recognizing first-time visitors with words of welcome. It goes on with giving special attention to returned users, saving personal preferences, serving up location-relevant content, and much more. The internet is not a private thing and incognito mode from chrome doesn’t save you.

A small personal profile of a user is internet cookies, that store information about user activity on websites. Almost all websites gather cookies and ask your permission to do that in the first visit of the site. They save information about your locations, products you were interested in, personally identifiable information like name, home address, telephone number, etc. This allows the site to show you the information that fits your needs.

But personalization doesn’t end here. Spotify and Yandex music suggest songs that you may like. How they do that? Data analytics, deep learning, and AI – this is all about providing data-driven experience. Starbucks uses smart personalization with the «Featured» tab. The app picks what you may want based on your previously ordered items, thus users don’t need to browse the full menu to find something new they may like.

Cut a Long Story Short… Let’s Skip a Long Conclusion!

Did you get the message from this article? Yeah, that’s right. Don’t create UX For the sake of it. Use it to Convey the message to your users and highlight ideas that you want to be heard. That’s it for our collection of major UX trends in 2022. Thanks for reading.

If you liked our blog, please read our latest posts:

The post Top UX Trends in 2022 for Mobile Apps appeared first on Flatlogic Blog.

14 Great Admin Panel Themes for Ecommerce

Table of content

Types of eCommerce platforms
Developing custom solutions
eCommerce templates explained
Notable eCommerce templates

Bonus!Honorable Mention: Hound

Creating your own Apps with Flatlogic Platform

Types of eCommerce platforms

Here’s a thing about modern software development: when you want to launch an online store, you usually turn to ready-made platforms, both paid and free. We all know platforms like Magento, Shopify, BigCommerce, WooCommerce, and others. Obviously, each one has its own pros and cons. The obvious advantage of using such solutions is the speed of deploying stores – for example, Shopify takes over the entire technical process of setting up the store. Magento offers various hosting partners as well.

Such an approach has certain disadvantages: big waste of money, getting stuck on a single technology, lack of technical support, lack of customization, searching for developers, and so on.

Developing custom solution

Taking all these disadvantages, you may be tempted to write your own solution. However, we recommend doing this in these cases only:

If your store is rather non-standard and you need deep customization of existing solutions. Then it really may be easier for you to write your own solution. For example, not all ready-made platforms are suitable for selling digital goods.
If you already have developers that know specific technology. For example, you happen to have people on your team who can work on React + Node.js. In that case you can write a custom solution that ready-made eCommerce platforms cannot provide.
Another advantage of custom solutions is the store speed. If you lay the right architectural solutions under the hood from the start, you can end up with a very fast-acting store.
If you want to save money and not give it to a third party. For example, you don’t want to pay for a Shopify subscription or buy the Magento enterprise version.

In general, the choice on how to develop an online store depends on the following criteria:

The size of the planned store;
What the store will sell;
How fast the store will grow;
Availability of developers in the company;
How much you can allocate on development and support.

Ecommerce templates explained

If you are still reading this, we suppose you still want a self-written solution for building online stores and ask the question – how can I save time and money?

There is a solution called ready-made templates for online stores. Basically, you get an already written code base and design at your disposal for a one-time payment. Prices for such templates can be ridiculously low, and the benefits are enormous. According to our internal calculations, such a product can save you $20k in the initial development alone. You can buy such products at a specialized template marketplace or from template premium vendors.

Ready-made e-commerce solutions can use the following technologies:

React, Vue, Angular on the front-end;
Node.js, PHP, Python for backend;
MySQL, PostgreSQL as a base.

Also, as options, various analytics tools can be connected and configured there – for example, Google Analytics, Google Tag Manager, etc. Payment systems can be also integrated.

In this article, we will simply list e-commerce templates from various vendors. Before we do this, let’s analyze the minimum functionality and components that must be present in such a product.

Of course, you need to have a shopping cart feature;
Product management system;
Product catalog;
Login and registration forms;
Checkout feature;
For sure: different elements like buttons, logos, tables to edit your shop;
Nowadays it is critical that your eCommerce website would be responsive;
It’s also good if your eCommerce theme has a search option.

We would also like to warn you that e-commerce templates are divided into 4 types:

Templates and themes made for a specific technology. For example, themes that only suit for Shopify, Magento, Prestashop;

Storefront templates that you can integrate with any backend and admin template;

Admin templates (panels) that can be connected to the existing online store or data to manage it;

Full eCcommerce templates that have both the front-end (storefront) part and the admin panel inside (back-end).

In this article, we will review products from the last 3 categories.

Notable Ecommerce Templates

React Material Admin Node.js

Live demo:
Price and License: 2-tier pricing, from $149 for the personal license to $699 for dev license
The technology used: React, Material-UI, Node.js, PostgreSQL
Number of sales (if applicable): 30+
Type of Product: Admin Panel

The first template we need to take a closer look at is React Material UI Admin by the Flatlogic team. It uses Node.js and Material-UI framework and comes with Material design. Describing the advantages, here’s one of the central points – it doesn’t use Bootstrap and jQuery. The Ecommerce section has an option to Manage products. Products Grid and Product Page are also there. By purchasing this template, the user can have both front-end and back-end for apps or websites. You can use it for showing data analytics, e-commerce, or any other kind of app.

Among other major components, there are various UI elements: 

Navigation bar. 

Notable Features

Three color themes;
Sketch version files included;
Fully responsive;
Node.js & PostgreSQL integrated;
Full CRUD Application;
Various Charts Libraries;
E-Commerce Section;

Support and Updates Policy

Support is provided via email. The team promises to answer in 24 hours. Major updates come every 3-4 months, often including upgrades of the framework and libs versions.

Ecommerce React Template

Live demo:
Price and License: 2-tier pricing, from $149 for the personal license to $699 for dev license
The technology used: React, Node.js, PostgreSQL
Number of sales (if applicable): 30+
Type of Product: Full ecommerce store template with backend and DB

Ecommerce React Template is a ready-made fully working ecommerce store built with the latest technologies and best practices. In this React Ecommerce template Flatlogic team have used React for the front-end, NodeJS for the back-end, PostgreSQL for storing the data and Sequelize as ORM.

Using an E-commerce React Template you will get a complete E-commerce store with front-end, backend, and admin parts. This E-commerce template is SEO-friendly with the help of NextJS – server-side rendering technology.

Notable Features

Full ecommerce store;
Fully responsive;
Node.js & PostgreSQL integrated;
Full CRUD Application;
Blog and CMS for it;
Registration with email / password / name;
Stripe integration.

Support and Updates Policy

Support is provided via email. The team promises to answer in 24 hours. Major updates come every 3-4 months, often including upgrades of the framework and libs versions.

Active Ecommerce CMS

Live demo:
Price and License: 2-tier plan, from $59 for the regular license to $525 for extended
The technology used: PHP, SQL, Javascript
Number of sales (if applicable): 2082 on 25 Jan 2021
Type of Product: Full E-commerce template with CMS (back-end) and front-end part

Active eCommerce CMS is a complete online store template with the database, front-end, and back-end parts. It includes both parts of a proper online shop: storefront and admin panel to manage it. With this type of template, you need to simply set up a payment system, hosting, and add your first items to start selling online.

The design is quite similar to Aliexpress, but we think this is an advantage. The layout will be familiar to most customers. The entire layout is 100% responsive.

Notable features

Multi-vendor eCommerce system;
Checkout system inside;
Dynamic homepage;
Multiple languages;
Multiple color theme;
Pre-installed payment integrations like Paypal or Stripe;

Discount system;
Suggestive search.

Support and Updates Policy

The policy says that Active eCommerce CMS has support for 6 months from the purchase date. During the product support period, customers can report and discuss bugs and minor item defects with the author, and authors are expected to be available to assist with reported bugs.

Sing App Vue Node.js

Live demo:
Price and License: 2-tier pricing, start from $149 for the personal license to $699 for dev license
Technology used: Vue, Node.js, PostgreSQL
Number of sales (if applicable): 42
Type of Product: Admin Panel

Sing App is a Vue Admin Theme with dozens of pre-built components and features that make your developer’s life easier. Sing App Vue gives you plenty of unique pages and components to help you build a custom admin dashboard or integrate with the existing online shop. The project works very fast and uses the latest technologies.

Notable features

Various charts to analyze sales;
Several types of tables;
Buttons and Forms;
Ecommerce section with Product Management, Product Grid, and example of the Product page.

Support and Updates Policy

Support is provided via email: the team says they answer in 24 hours. Major updates come every 3-4 months. They often include upgrades of the framework and libs versions.


Live demo:
Price and License: 3 tier options, starting from $39 for a regular license
Technology used: Bootstrap 4, SASS, NPM, Gulp
Number of sales (if applicable): website claims 10000+ paying users
Type of product: Admin Template

Azia is a classic bootstrap 4 admin template. You can buy it both on the developer site and on ThemeForest. Made in light colors, it is generally designed in business style. It has a contrasting color scheme and is quite easy to read thanks to this. 

The template has the following main blocks:

Apps and pages;
UI Elements;

How can you use this template for your online store? You can connect this product to an existing store via API and track the following indicators:

Sales monitoring helps you track the following: Revenue, Total Quantity, Profit. There is also an interactive map with sales over the country.
There is also a Product Management Dashboard that helps you to see Conversions, Number of Customers, Activity feed, and others.
And several dashboards such as Ad Campaign, Helpdesk, Web Analytics.

Notable Features

Bootstrap 4
10 Pre-built Dashboard Templates
1000+ Font Icons
500+ UI Elements
Pre-built Apps (Mailbox, Chat, Contacts, Calendar, etc.)
Pre-built Pages (Sign In, Signup, Error Page, etc.)
Form Validation
Tables and DataTables
Addon Utilities and Helper Classes

Support and Updates Policy

1 year of premium support from the team. Regular updates are stated. Support is working through the ticket system.

Light Blue React Node.js

Live demo:
Price and License: 2-tier pricing, starting from $149 for the personal license to $699 for dev license
The technology used: React, Node.js, PostgreSQL
Number of sales (if applicable): 51
Type of Product: Admin Panel

This admin template, designed in light blue colors, is made with React technology and Node.js back-end. You can easily use it for E-commerce apps because of special pre-built features like Product Management, Grids, Charts, login/logout forms, and others.

Some of the crucial components are the e-commerce product page and the product grid. The first one provides you with all details of your product, gives a description of it, and has the rating and reviews. The second one displays your products according to the chosen type, brand, size, color, range, and sort.

You can also find such components as:

Several types of tables;

This dashboard template is a great start if you are building E-Commerce apps, CMS, SASS web apps, CRM, etc. It contains ready-to-use working Authentication, Social Login, and Product Management components.

Notable Features

Over 30 unique pages;
Node.js & PostgreSQL integrated;
CRUD Application node js;
Fully responsive;
8 Chart Libraries;
Fully Documented Codebase.

Support and Updates

Support, as in other Flatlogic products is provided via email: the team says they answer in 24 hours. Major updates come every 3-4 months. They often include upgrades of the framework and libs versions.

Plus admin

Live demo:
Price and License: 3-tier options, starting from $39 for a regular license
The technology used: Vue, Angular, React
Number of sales (if applicable):
Type of Product: Admin Template

Like the previous product, you can use this admin panel with an online store by connecting it with existing data via API. The product uses blue colors to highlight its corporate identity.

This product has a whole section dedicated to E-commerce, which includes elements such as:

Email templates
Pricing Table
Product Catalog
Project List

In addition to functions for an online store, in this template you will also find such interesting additions as Kanban board, Todo list, Ticketing system, RTL support, Text, and even code editor.

Notable Features

With Ecommerce elements, you receive such features as:

Sorting products into different categories;
Option to cancel orders and check your order history;
Payments, Returns, Reports, Transfers, and more.

Support and Updates Policy

1 year of premium support from the team and regular updates are stated. Support is working through the ticket system.


Live demo:
Price and License: 3-tier options, starting from $19 for a single license
The technology used: HTML
Number of sales (if applicable):
Type of Product: Shop front end

This product belongs to the category of those that provide only the front end part of the online store, so it should be evaluated from four sides:

Speed – we can check it by trying out the demo;
The number of different elements and features;
Design –  is a purely subjective thing, but you can still create your own opinion;
Quality of the code – unfortunately, we cannot check it until we buy it.

This template is tailored for setting up an online store to sell bakery products, but for sure it can be used for other purposes as well. In order to use this template, you will need a little love, since you will also need to connect an e-commerce CMS to it.

The product has a nice neat design, using baked goods colors. The template looks good both on a mobile phone and on a tablet.

Notable features

Inside the product, you will find stuff like the shop screen itself, skill bars, testimonials, Google maps, social media icons, and a functional contact form. No complaints about the speed of work whatsoever.

Support and Updates Policy

Support covers getting up and helping in theme setup, as well as help with using features, theme options and bug fixes.


Live demo:
Price and License: 2-tier plan, from $24 for the regular license to $699 to extended
The technology used: HTML, Laravel
Number of sales (if applicable): 6800+
Type of Product: Admin Panel

Materialize is a material design template made with HTML and Laravel with 5 layout options. The product has a great collection of material design animation & widgets, UI Elements, jQuery plugins. In terms of Ecommerce, the template has a specific block named “eCommerce” which includes the Product page and Pricing. To use this product as E-commerce, you need to integrate it with your database and storefront.

Notable Features

Pre-build applications: Chat, Email, ToDo, Kanban, App full Calendar, Invoice, File Manager
Several Dashboards
RTL Supported
Multi-Language Support
5 menu style variations
Charts: Chartjs, Chartist, and Sparkline Charts

Support and Updates Policy

Support is provided on bugs and issues through tickets in ThemeForest. Updates come once in 3 months.


Live demo:
Price and License: 3-tier options, starting from $24 for a single license to $399 for Extended
Technology used: Bootstrap 4, SASS, Gulp
Number of sales (if applicable):
Type of Product: Admin Panel

Chameleon is a Bootstrap 4 admin panel from Themeselection. As with other similar products to use with online stores, you need to plug in your existing data. 

Notable Features

The following components will help with managing an online shop:

Ecommerce dashboard, where you can see Products Summary, Order Activity, Quarterly Sales, Number of Customers;
Analytics dashboards with Revenue and Income stats;
Apps like Email application, Chat application, Invoice, Contact list;
Various tables and charts.

Support and Updates Policy

Themeselection offers support for all of the paid products, in case if you face any issues or if something isn’t working as advertised.


Live demo:
Price and License: One type of license for $15
Technology used: Bootstrap
Number of sales (if applicable):
Type of Product: Admin Panel

Shoppy is an admin template specially made for online stores. You just need to integrate it with the existing solution. This eCommerce admin panel template is built upon HTML 5, CSS 3, and Bootstrap framework. 

Notable Features

Shoppy comes with an E-Commerce section that has Product listings with Prices and Flat style Pricing Panels (opens a pop-up on-click with Order processing information – Shipping and Billing).

This template also contains components like:

Grids and Portlets;
Animated Buttons;
Authentication Pages (Sign-up/Log-in);
Charts (Circular, Bar, Pie, Polar, and Line)

Support and Updates Policy

We haven’t found any evidence of support policy on the website.


Live demo:
Price and License: 4-tier plan, starting from $39 for single-use to $499 for Extended license
Technology used: Bootstrap, Sass, Gulp
Number of sales (if applicable): 368 sales as of 26 Jan 2021
Type of Product: Admin Panel

Xtreme is a classic Bootstrap 4 admin dashboard with eCommerce features that helps manage your online store. It packs a lot of UI elements along with a pre-constructed e-commerce setup and a lot of applications for managing an eCommerce business. 

You can see widgets that show what products availability in the shop and what might need an update. You will be able to configure the datasheet with the tables, helping to show your revenues and other details. Small details like taskboards, to-do lists, and ticketing systems are already integrated into this template to save your valuable time.

Notable Features

500+ UI Components;
Dark and Light Sidebar;
RTL ready;
100+ Page templates;
Form validations.

Support and Updates Policy

Support is provided through tickets only for premium products.


Live demo:
Price and License: 4-tier plan, starting from $39 for single-use to $499 for Extended license
Technology used: Bootstrap, Sass, Gulp
Number of sales (if applicable): 726 sales as of 26 Jan 2021
Type of Product: Admin Panel

Monster is another Bootstrap 4 admin template product from Wrappixel. It comes with a very big library of components, which will help you to set up your e-commerce website admin panel. 

For analytics and data collection, you will get visually appealing charts that simplify the operations and calculations necessary to take discussions and actions. Team management applications like chatting, inbox, and task management via Calendar are also strong in this template. Thus this project can be a great fit into your existing eCommerce storefront.

Notable Features

This template includes a lot of cards, widgets, and functional components like toasters, nested lists, and so on.

The other notable features:

Notes Application;
Ticker Application;
To-do app;
RTL ready;
3000+ Font icons.

Support and Updates Policy

Support is provided through tickets only for premium products.

Able Pro

Live demo:
Price and License: 2-tier plan, from $25 for the regular license to $999 to extended
The technology used: HTML, Angular, React
Number of sales (if applicable): 2096 as of 26 Jan 2021
Type of Product: Admin Panel

Able is an advanced template made with Bootstrap, React, and Angular technologies. It has a wide range of pre-built applications like Hospital, CRM, Helpdesk, School, and of course E-commerce.

For e-commerce integration, it has separate segments that you can use on your e-commerce site. It has product pages where all things are set up by default with the most necessary parameters like reviews, ratings, and many more.

Notable Features

Data table;
Various Charts;
Built-In Search;

Support and Updates Policy

Support is provided through tickets.


Live demo:
Price and License: 3-tier plan starting from $59 for the personal license to $299 for Extended
The technology used: React, HTML
The number of sales (if applicable):
Type of Product: Storefront template

Flone is a React JS eCommerce template with a huge number of prebuilt components and pages. It is a storefront template, thus you need to plug it in with the CMS. It even comes with such features as SEO optimization, Black Friday homepage, automotive shop page, and many others that will help you develop a good-looking website.

Notable Features

38+ beautiful homepages;
7 header variations; 
Different footer variations; 
Product Tab View; 
Product Grid View; 
Product List View; 
Blog section view.

Support and Updates Policy

Support is provided through the ticket system for premium products.

Materio – Vuetify Vuejs Laravel Admin Template

Live Demo:
Price: starts from $49 for single-use
The technology used: Vuejs (No Jquery), Vue CLI, Laravel
Type of product: admin template

Materio Vuetify VueJS Laravel Admin Template – is the most developer-friendly & highly customizable Admin Dashboard Template based on popular front-end framework VueJS and back-end Laravel. Materio is not only fast and easy to use but highly scalable. Offering ultimate convenience and flexibility, you’ll be able to build whatever app you want with little hassle.

In addition, you can build premium-quality single-page applications with ease with the use of this Vuejs Laravel admin template. So, use this innovative Vuejs Laravel admin template to create eye-catching, high-quality, and high-performing single-page applications.


Utilizes Vuex, Vue Router, Webpack
3 Dashboard, RTL Support
Code Splitting, Lazy loading
API ready JWT Authentication flow
Access Control (even on CRUD operations)
Laravel Passport
Laravel Sanctum and many more


We have collected, in our opinion, the most suitable templates both for integration with existing stores and for creating stores from scratch.

Most of the presented products are admin panels with advanced functionality. With these, you can manage your products and analyze their performance.

It is worth noting that there are not so many high-quality products on the market, so choose your product carefully. We will recommend you to take a look at the Flatlogic admin templates and Materialize Admin Template: these have the best features and designs suitable for your project.

You can find great Admin templates and themes for eCommerce on the Flatlogic templates store. Feel free to use a 30% coupon code on any theme ECOMMERCE30.


Honorable mention: Hound

As we kept exploring web template market, some impressive entries came up. And while none were so groundbreaking they would shift our list’s order, we thought at least one deserved to appear on the list.

The Hound has over 90 pages, over 500 interface elements, and over 2k icons. With such versatility, we expected the Hound to be bloated and excessive but we were in for a surprise. The controls’ hierarchy turned out rigid and intuitive enough. We navigated it with ease, and we believe even a complete beginner can with just minimal research. The integration options are stellar. Maps, to-do lists, calendars, Google maps, charts, tables, and more. If there’s a feature you want in your eCommerce admin panel, the Hound most likely has it, and chances are it connects to outside services like clockwork.

The main downside we could see (literally) was the design. It can be fun and pretty. But an admin template is something you might have to look at for hours on end, and the Hound’s bright design is the opposite of neutral and unobtrusive. Still, we believe the Hound’s good sides outweigh the questionable aesthetics to the point where it deserves at least an honorable mention.



Creating Your Own Apps with Flatlogic Platform

We’ve covered 14 templates that are good in many regards but especially when used for e-Commerce projects. Now, let’s take a look at another path you can take.

Most web applications operate by using different combinations of basic functions. The combinations are different but the functions are the same. Standsrd web apps like the ones used in e-Commerce are sometimes called CRUD apps. CRUD stands for Create, Read, Update, and Delete. These are the most basic functions that most web applications perform. Understanding that, we simplified the process of app development to give everyone a shot, not only those with a team of dedicated developers.

To do this, go to the Flatlogic Platform and follow five simple steps.

#1: Choose the project’s name

This step is as simple as it sounds. Pick a name that is easy enough to associate with the project in case you end up with several of them.

#2: Select your Web App Stack

Decide what your App will run on. Choose underlying technologies for the front-end, the back-end, and the database. In the example shown in the screenshot, we’ve picked React for the admin panel, Node.js for the back-end, and MySQL for the database.

#3: Choose the Design

The Flatlogic Platform offers a variety of admin panel designs. There are lighter and darker themes, themes with Material Design elements, and our proprietary design patterns. Pick the one you’ll be able to look at for a long time.

#4: Create your Web App’s database schema

We’ve picked the technology the database runs on. Now it’s time to define tables, columns, types of data in them, and the relationships between those. At this step, you decide what the content of your App will mean. Furthermore, the Platform will automatically generate REST API docs for your App.

#5: Review and generate your App

Review the decisions you’ve made. If everything is as intended, hit “Create App”. After compiling for a little while, the Flatlogic Platform will offer you your very own App that you can push to GitHub and host in one click. Enjoy!

You might also like these articles

12+ Best Visual Studio Alternatives
Top 12 Bug Tracking Tools
Angular vs. Bootstrap – 6+ Key Differences, Pros, and Cons

The post 14 Great Admin Panel Themes for Ecommerce appeared first on Flatlogic Blog.

State of the Windows Forms Designer for .NET Applications

For the last several Visual Studio release cycles, the Windows Forms (WinForms) Team has been
working hard to bring the WinForms designer for .NET applications to parity with
the .NET Framework designer. As you may be aware, a new WinForms
designer was needed to support .NET Core 3.1 applications, and later .NET 5+
applications. The work required a near-complete rearchitecting of the designer,
as we responded to the differences between .NET and the .NET Framework based
WinForms designer everyone knows and loves. The goal of this blog post is to
give you some insight into the new architecture and what sorts of changes we
have made. And of course, how those changes may impact you as you create custom
controls and .NET WinForms applications.

After reading this blog post you will be familiar with the underlying problems
the new WinForms designer is meant to solve and have a high-level understanding
of the primary components in this new approach. Enjoy this look into the
designer architecture and stay tuned for future blogs!

A bit of history

WinForms was introduced with the first version of .NET and Visual Studio in
2001. WinForms itself can be thought of as a wrapper around the complex Win32
API. It was built so that enterprise developers didn’t need to be ace C++
developers to create data driven line-of-business applications. WinForms was
immediately a hit because of its WYSIWYG designer where even novice developers
could throw together an app in minutes for their business needs.

Until we added a support for .NET Core applications there was only a single
process, devenv.exe, that both the Visual Studio environment and the application
being designed ran within. But .NET Framework and .NET Core can’t both run
together within devenv.exe, and as a result we had to take the designer out of
, thus we called the new designer – WinForms Out of Process Designer (or
OOP designer for short).

Where are we today?

While we aimed at complete parity between the OOP designer and the .NET
Framework designer for the release of Visual Studio 2022,
there are still a few issues on our backlog. That said, the OOP designer in its current iteration
already has most of the significant improvements at all important levels:

Performance: Starting with Visual Studio 2019 v16.10, the performance of
the OOP designer has been improved considerably. We’ve worked on reducing
project load times and improved the experience of interacting with controls
on the design surface, like selecting and moving controls.

Databinding Support: WinForms in Visual Studio 2022 brings a
streamlined approach for managing Data Sources in the OOP designer with the
primary focus on Object Data Sources. This new approach is unique to the
OOP designer and .NET based applications.

WinForms Designer Extensibility SDK: Due to the conceptional differences
between the OOP designer and the .NET Framework designer, providers for 3rd
party controls for .NET will need to use a dedicated WinForms Designer SDK
to develop custom Control Designers which run in the context of the OOP
designer. We have published a pre-release version of the SDK last month as a
NuGet package, and you can download it
will be updating this package to make it provide IntelliSense in the first
quarter of 2022. There will also be a dedicated blog post about the SDK in
the coming weeks.

A look under the hood of the WinForms designer

Designing Forms and UserControls with the WinForms designer holds a couple of
surprises for people who look under the hood of the designer for the first time:

The designer doesn’t “save” (serialize) the layout in some sort of XML or
JSON. It serializes the Forms/UserControl definition directly to code – in
the new OOP designer that is either C# or Visual Basic .NET. When the user
places a Button on a Form, the code for creating this Button and assigning
its properties is generated into a method of the Form called
`InitializeComponent`. When the Form is opened in the designer, the
`InitializeComponent` method is parsed and a shadow .NET assembly is
being created on the fly from that code. This assembly contains an
executable version of `InitializeComponent` which is loaded in the context
of the designer. `InitializeComponent` method is then executed, and the
designer is now able to display the resulting Form with all its control
definitions and assigned properties. We call this kind of serialization
Code Document Object Model serialization, or CodeDOM serialization for
short. This is the reason, you shouldn’t edit `InitializeComponent`
directly: the next time you visually edit something on the Form and save it,
the method gets overwritten, and your edits will be lost.
All WinForms controls have two code layers to them. First there is the code
for a control that runs during runtime, and then there is a control
designer, which controls the behavior at design-time. The control designer
functionality for each control is not implemented in the designer
itself. Rather, a dedicated control designer interacts with Visual Studio
services and features.Let’s look at `SplitContainer` as an example:

The design-time behavior of the SplitContainer is implemented in an
associated designer, in this case the `SplitContainerDesigner`. This class
provides the key functionality for the design-time experience of the
`SplitContainer` control:

The way the outer Panel and the inner Panels get selected on mouse
The ability of the splitter bar to be moved to adjust the sizes of the
inner panels.
To provide the Designer Action Glyph, which allows a developer using the
control to manage the Designer Actions through the respective short cut

When we decided to support apps built on .NET Core 3.1 and .NET 5+ in
the original designer we faced a major challenge. Visual Studio is
built on .NET Framework but needs to round-trip the designer code by serializing
and deserializing this code for projects which target a different runtime. While, with some
limitations, you can run .NET Framework based types in a .NET Core/.NET 5+
applications, the reverse is not true. This problem is known as “type
resolution problem
”. A great example of this can be seen in the TextBox
control: in .NET Core 3.1 we added a new property called `PlaceholderText`. In
.NET Framework that property does not exist on `TextBox`. So, if the .NET
Framework based CodeDom Serializer (running in Visual Studio) encountered the
`PlaceholderText` property it would fail.

In addition, a Form with all its controls and components renders itself in the designer
at design time. Therefore, the code that instantiates the form and shows it in the
Designer window must also be executed in .NET and not in .NET Framework, so that
newer properties available only in .NET also reflect the actual appearance and
behavior of the controls, components, and ultimately the entire Form or UserControl.

Because we plan to continue innovating and adding new features in the future,
the problem only grows over time. So we had to design a mechanism that supported
such cross-framework interactions between the WinForms designer and Visual Studio.

Enter the DesignToolsServer

Developers need to see their Forms in the designer looking precisely the way it
will at runtime (WYSIWYG). Whether it is `PlaceholderText` property from the
earlier example, or the layout of a form with the desired default font – the
CodeDom serializer must run in the context of the version of .NET the project is
targeting. And we naturally can’t do that, if the CodeDom serialization is
running in the same process as Visual Studio. To solve this, we run the designer
out-of-process (hence the moniker Out of Process Designer) in a new
.NET (Core) process called DesignToolsServer. The DesignToolsServer process
runs the same version of .NET and the same bitness (x86 or x64) as your

Now, when you double-click on a Form or a UserControl in Solution Explorer,
Visual Studio’s designer loader service determines the targeted .NET version and
launches a DesignToolsServer process. Then the designer loader passes the code
from the `InitializeComponent` method to the DesignToolsServer process where
it can now execute under the desired .NET runtime and is now able to deal with
every type and property this runtime provides.

While going out of process solves the type-resolution-problem , it introduces a
few other challenges around the user interaction inside Visual Studio. For
example, the Property Browser, which is part of Visual Studio (and therefore
also .NET Framework based). It is supposed to show the .NET Types, but it can’t
do this for the same reasons the CodeDom serializer cannot (de)serialize .NET

Custom Property Descriptors and Control Proxies

To facilitate interaction with Visual Studio, the DesignToolsServer introduces
proxy classes for the components and controls on a form which are created in the
Visual Studio process along with the real components and controls on the form in
the DesignToolsServer.exe process. For each one on the form, an object proxy is
created. And while the real controls live in the DesignToolsServer process, the
object proxy instances live in the client – the Visual Studio process. If you
now select an actual .NET WinForms control on the form, from Visual Studio’s
perspective an object proxy is what gets selected. And that object proxy doesn’t
have the same properties of its counterpart control on the server side. It
rather maps the control’s properties 1:1 with custom proxy property
descriptors through which Visual Studio can talk to the server process.

So, clicking now on a button control on the form, leads to the following
(somewhat simplified) chain of events to get the properties to show in the
Property Browser:

The mouse click happens on special window in the Visual Studio process,
called the Input Shield. It acts like a sneeze guard, if you will, and is
purely to intercept the mouse messages which it sends to the
DesignToolsServer process.
The DesignToolsServer receives the mouse click and passes it to the
Behavior Service. The Behavior Service finds the control and passes it to
the Selection Service that takes the necessary steps to select that
In that process, the Behavior Service has also located the correlating
Control Designer, and initiates the necessary steps to let that Control
Designer render whatever adorners and glyphs it needs to render for that
control. Think of the Designer Action Glyphs or the special selection
markers from the earlier SplitPanel example.
The Selection Service reports the control selection back to Visual Studio’s
Selection Service.
Visual Studio now knows, what object proxy maps to the selected control in
the DesignToolsServer. The Visual Studio’s selection service selects that
object proxy. This again triggers an update for the values of the selected
control (object proxy) in the Property Browser.
The Property Browser in turn now queries the Property Descriptors of the
selected object proxy which are mapped to the proxy descriptors of the
actual control in the DesignToolsServer’s process. So, for each property the
Property Browser needs to update, the Property Browser calls GetValue on
the respective proxy Property Descriptor, which leads to a cross-process
call to the server to retrieve the actual value of that control’s
property, which is eventually displayed in the Property Browser.

Compatibility of Custom Controls with the DesignToolsServer

With the knowledge of these new concepts, it is obvious that adjustments to
existing custom control designers targeting .NET will be required. The extent to
which the adjustments are necessary depends purely on how extensively the custom
control utilize the typical custom Control Designer functionality.

Here’s a simple a simplified guide on how to decide whether a control would
likely require adjustments for the OOP designer for typical Designer

Whenever a control brings a special UI functionality (like custom adorners,
snap lines, glyphs, mouse interactions, etc.), the control will need to be
adjusted for .NET and at least recompiled against the new WinForms
Designer SDK. The reason for this is that the OOP Designer re-implements a
lot of the original functionality, and that functionality is organized in
different namespaces. Without recompiling, the new OOP designer wouldn’t
know how to deal with the control designer and would not recognize the
control designer types as such.
If the control brings its own Type Editor, then the required adjustments
are more considerable. This is the same process the team underwent
with the library of the standard controls: While the modal dialogs
of a control’s designer can only work in the context of the Visual Studio
process, the rest of the control’s designer runs in the context of the
DesignToolServer’s process. That means a control with a custom type editor,
which is shown in a modal dialog, always needs a Client/Server
Control Designer combination. It needs to communicate between the modal UI
in the Visual Studio process and the actual instance of the control in the
DesignToolsServer process.
Since the control and most of its designers now live in the
DesignToolsServer (instead of Visual Studio) process, reacting to a
developer’s UI interaction by handling those in WndProc code won’t work
anymore. As already mentioned, we will publishing a blog post that will
cover the authoring of custom controls for .NET and dive into the .NET
Windows Forms SDK in more details.

If a Control’s property, however, does only implement a custom Converter, then
no change is needed, unless the converter needs a custom painting in the
property grid. Properties, however, which are using custom Enums or provide a
list of standard settings through the custom Converter at design time, are
running just fine.

Features yet to come and phased out Features

While we reached almost parity with the .NET Framework Designer, there are still
a few areas where the OOP Designer needs work:

The Tab Order interaction has been implemented and is currently tested.
This feature will be available in Visual Studio 17.1 Preview 3.
Apart from the Tab Order functionality you already found in the .NET
Framework Designer, we have planned to extend the Tab Order Interaction,
which will make it easier to reorder especially in large forms or parts of a
large form.
The Component Designer has not been finalized yet, and we’re actively
working on that. The usage of Components, however, is fully supported, and
the Component Tray has parity with the .NET Framework Designer. Note though,
that not all components which were available by default in the ToolBox in
.NET Framework are supported in the OOP Designer. We have decided not to
support those components in the OOP Designer, which are only available
through .NET Platform Extensions (see Windows Compatibility
You can, of course, use those components directly in code in .NET, should
you still need them.
The Typed DataSet Designer is not part of the OOP Designer. The same is
true for type editors which lead directly to the SQL Query Editor in .NET
Framework (like the DataSet component editor). Typed DataSets need the
so-called Data Source Provider Service, which does not belong to WinForms.
While we have modernized the support for Object Data Sources and encourage
Developers to use this along with more modern ORMs like EFCore, the OOP
Designer can handle typed DataSets on existing forms, which have been ported
from .NET Framework projects, in a limited scope.

Summery and key takeaways

So, while most of the basic Designer functionality is in parity with the .NET Framework Designer,
there are key differences:

We have taken the .NET WinForms Designer out of proc. While Visual Studio 2022 is 64-Bit .NET Framework only,
the new Designer’s server process runs in the respective bitness of the project and as a .NET process.
That, however, comes with a couple of breaking changes, mostly around the authoring of Control Designers.
Databinding is focused around Object Data Sources. While legacy support for maintaining
Typed DataSet-based data layers is currently supported in a limited way, for .NET we recommend
using modern ORMs like EntityFramework or even better: EFCore. Use the DesignBindingPicker
and the new Databinding Dialog to set up Object Data Sources.
Control library authors, who need more Design Time Support for their controls than custom type editors,
need the WinForms Designer Extensibility SDK.
Framework control designers no longer work without adjusting them for the
new OOP architecture of the .NET WinForms Designer.

Let us know what topics you would like hear from us around the WinForms Designer-
the new Object Data Source functionality in the OOP Designer and the WinForms Designer SDK
are the topics already in the making and on top of our list.

Please also note that the WinForms .NET runtime is open source, and you can contribute!
If you have ideas, encountered bugs, or even want to take on PRs around the WinForms runtime,
have a look at the WinForms Github repo.
If you have suggestions around the WinForms Designer,
feel free to file new issues there as well.

Happy coding!

The post State of the Windows Forms Designer for .NET Applications appeared first on .NET Blog.

Top 15 React App Ideas for Web Developers in 2022

Quick Intro
Why React?

React Based Ideas for Full Stack Web ApplicationsSocial Media App 

e-Commerce App
Productivity App
Entertainment App (e.g. game app)
Dating App
Chat app/Messanger
Books app
Expense tracking app
Sport tracking app / Workout tracker
Instant Messaging Application
Music app
Todo App
Language learning App

Create a Web App With Flatlogic
Suggested Articles

Quick Intro

Recently we have published an article on this very topic, called 6 React Project Ideas to Help You Learn by Doing. And out with the new, in with the old. The best way to learn ReactJS is certainly through direct practice. If you’re convinced that ideas which have not been executed cost nothing, then feel free to browse our list of React app ideas and finally put them to the test.

Why React

There are numerous questions asked in Google like: Is React still in demand? Is React worth learning in 2021? Is React still popular? The answer is YES. US multinational giants like Netflix, eBay, Bloomberg and dozens of other use React library for their websites and web apps as well.

The motivation to create your own React app can be just any. You practice your coding and gain experience; you create something meaningful for your web developer portfolio; you make a CRUD app just from scratch, and it remains fully yours, and it is always pleasing to do something on your own.

Just look at the graph of downloads of popular frameworks by npm trends. The statistics speak for themselves and you will scarcely find a better technology for building web and mobile applications user interfaces. React remains the leading technology for building SPAs, and is trusted by thousands of great enterprises as well as by small fledgling and burgeoning businesses.

React is a library with already existing code;
React helps to simplify the web app building process making it scalable and consistent;
React was invented and currently maintained by the best developers in the world, the team which developed Facebook;
React is about JSX, that is a JavaScript syntax, and that means that if you have first-hand knowledge of the ubiquitous JavaScript, you won’t have any problems creating your React app. So, let me show you which applications could be a nice catch for your future development.

Top 15 Project Ideas for Web Apps to Build on ReactJS

1. Social Media App

Yes, you may be confused by this point, because the market is overwhelmed with a range of popular social platforms, and there are enough leaders like YouTube, Instagram, TikTok or Twitter, though who knows, every day we see new trends and newcomers e.g. everyone noticed the short burst of popularity of Clubhouse, and its quite abrupt passing away. So, you can build your prototype of Instagram, Twitter, or Tumbler with the help of React. Socials are the place where we catch and spread emotions online and the power of visuals are priceless. So Be sure to create a catchy and memorable UI design to capture your users’ attention.

2. eCommerce App

Ecommerce app development is a clear step to establishing your business CMS. And probably Reactjs will become that widely spread technology to build your high performing eCommerce platform, and optimize development time and cost as well. Thanks to React performance and flexibility you can build any kind of modern app with the functionality of shopping cart software, just like Shopify, AliExpress or Amazon. Use Flatlogic eCommerce template with the ready admin panel, frontend and backend for your online store.

Building Online Store on React

3. Productivity App

Best productivity app can be also built with the help of ReactJS. Regarding some examples, it can be another Calendly, Todoist, or Asana. From browser plugins to different services that help you maintain relationships, productivity apps assist with various types of tasks. Productivity applications help you to perform better, organize and monitor your daily tasks or activities, keep some records or daily notes, and so on. All of them have various goals and corresponding helpful functionalities. For instance, calories tracker, distraction trackers, reminder apps, and so on. From browser plugins to different services that help you maintain important relationships, productivity apps do it all.

4. Entertainment App

Entertainment applications are probably one of the most popular applications. This is all about music, video, games, or any media platforms or streaming services. There are well-known social media platforms like YouTube, Spotify, and Medium. Entertainment applications are probably one of the most popular applications. This is all about music, video, games, or any media platforms or streaming services. There are well-known social media platforms like YouTube, Spotify, and Medium. With React you can build some simple logic game, kinda Tetris, or aim to make something more, like a Netflix clone. Then you will certainly need npm package react-player for playing media; Gatbsy or NextJS; Firebase for storage functions and data manipulations; and Typesense for enabling search option by name whether it’s a movie, track, etc.

5. Blog

Creating a simple CMS for blogging is another way to implement React technology in the way it should be. React is just an option for a service like Wix. Btw, we’ve recently prepared a full guide on how to make a React CMS for blog. By default, you can try to build your store with, but the faster way is to build your content management platform using web app builder.

The list of features for blog on React will be just like the majority of blog platforms has. It is a sort of hierarchical system of relations. For instance, firstly you build the components to display the publication, then you build a component to display to organize them as a grid; then add the upload an image functionality and a way to edit and publish a post, and so on. Various add-on like upvotes, reactions, comments, views displayed may become the next level options.

6. Chat / Instant Messaging App

Among other React project ideas, you may want to build a chat application. Any messaging app is a kind of chat application with a sender and a receiver. However, you can also build either a video chat app or any other live chat. The first chat application that came to our mind is ChatRoulette, and its frontend also was built with the help of Reactjs. You might also remember Facebook Messenger or well known in the IT world and the world of software developers, Slack. Here you can have a glance at our ultimate step-by-step guide on how to build a chat app with React.

7. Books applications

Just like goodreads, an american cataloging website for booklovers, you can create an app for managing your reading flow. Or, libib, a library management service that helps to catalog your favorite media like books, music,  videos and games. What is a standard book app? It is like a catalogue/library, or a CMS if you want, with a list of books, which you have in currently-reading tab; to-read tab, and already read; and a search bar.

8. Expense tracking application / Money tracker

You must have heard about Quickbooks or Expensify. The last one is probably the most popular because it has a wider audience, and is not just another budget tracker or a tool for bookkeepers, but a powerful system for recording and managing your finances. This type of app is usually aimed more at resolving business issues, like real-time reporting, invoicing and so on, though you may choose to build your own, simplified version of the budget tracker on React.

9. Language Learning App

Language is power and knowing a foreign language will help to get hired and boost your career. and Create your best language-learning app with React, CSS and Typescript for declaring data type of variables. You can start with the basic word insertion exercise or matching terms exercise, where you will need drag and drop elements.

10. Fitness App

How to build a fitness app using React? Just like the other applications, fitness applications help to track your sport activity during the day. Sports app provide us with the data that we add to the app, reporting on number of running distance, sport streaming events with winning odds and score, or betting app, whatever. React library was used by BBC sports,

11. To Do App

ToDo app is a nice idea for a React project for those who started their programming journey relatively recently. You can do without side libraries like Redux or MobX. As the topic implies, we are going to be building a To-Do application with React. Do not expect any surprises such as managing a state with a state management library like Flux or Redux. I promise it will strictly be React. Maybe in the following articles, we can employ something like Redux but we want to focus on React and make sure everybody is good with React itself.

12. Sport tracking app

Track your daily sport achievements via an app like a fitness tracker or workout tracker that can be easily built with React, Firebase and, for instance, Google Material UI components. A detailed how-to guide you can find on logrocket. The principle and the basic steps of building a sports app are just the same: project setting up; building authentication and authorization; creating a custom calendar; adding a database and running in production deployment.

13. Dating App

The US dating App Market shows that Tinder is still the most popular dating app in the USA. More than 7.8 millions people choose Tinder monthly, and the majority of them are between 21 ans 44 age. Yes, the idea of creating your own dating app seems quite challenging and maybe overly ambitious, but you can start with creating your own CMS for an app like Tinder. On the flip side, with the same approach, you can build a Tinder for pets. I bet $100, you haven’t made this ide yet. The key features of any dating app will become profile setting up and profile verification, geolocation, matching/unmatching option, push notifications, and again chatting.

14. Music App

Just one more Dezeer or Spotify can become your next React project for your portfolio. For instance, It can become a NextJS app with Firebase Cloud storage for a library, Firestore database for making hierarchical data structures, and let’s take Lucidworks or Algolia for providing search feature. Btw, digitalocean shares an in-depth tutorial on how to make a music player with React and Electron.

15. Sleeping Tracker App

A sleep habit tracker is a good and simple idea to build on React. The idea is in tracking your sleep time, wake up time, and exact sleep duration. Users can add, edit, or remove any sleep entries. You might need React, HTML and CSS for the front end part, Java, C#, or even Node.JS for backend, PostgreSQL or MySQL for the database.

How to Make an Admin Panel/CMS for Your Entities with Flatlogic

We don’t need to go far for React app ideas, beginners and advanced coders can just start with the Flatlogic platform. Don’t forget to sign in before creating your demo app`!

With the help of Flatlogic, you can create any type of application skeleton. For example, it may become your E-commerce platform(watch our short video guide above), CRM, reporting app or a booking store. The generated application is a foundation for further development with data management, user authentication, and a structure.

Choose the technologies for the frontend and the backend parts, then move to the design stage of your app UI, set up the database with a number of entities you need, and finally tap to build your app. After deployment, you’ll be able to download the source code, edit and improve it.

I highly recommend you check the full version of Flatlogic documentation to get the gist of how the application is being built step by step.

In a Nutshell

These are just some of the best react projects that could be developed with React. These app ideas are good both for beginners and for experienced developers. If you feel like creating your own app, try out Flatlogic and share your feedback on our forum. We always appreciate you participating in the development of something new and powerful.

Suggested Articles

Best React Open Source Projects
What is Next.js and Top Next.js Templates
10 Best IDEs for React.JS in 2021

The post Top 15 React App Ideas for Web Developers in 2022 appeared first on Flatlogic Blog.

339: Apollo at CodePen

Rachel and Chris chat all things Apollo GraphQL. Apollo is in this weird category of software where like by far most websites do not need it or anything like it. But for CodePen, we consider it nearly essential. The typical sales pitch for GraphQL applies to us for sure (e.g. only ask for the data you need!) but you can add to that the fact that it is empowering for front-end developers, which we have plenty of here on the CodePen Staff. But beyond GraphQL, we need ergonomic ways to write those queries and trust technology to do the right things. For example, 15 components on any given page might need to know the PRO status of a user, and thus be part of that components query, but the network very much does not need to do 15 requests. Apollo does stuff like figuring out what the page needs in aggregate and requesting is and dissemeninating that information as efficiently as possible and caching it. Plus we leverage Apollo for client-only state too, meaning we have a unified system for state management that plays very nicely in our React-based world.

Time Jumps

00:34 Working on Apollo stuff at CodePen

02:48 How do you think of GraphQL and Apollo?

06:52 Dealing with pagination

09:04 Building out the server for GraphQL

13:48 Sponsor: Jetpack Backup

15:28 Apollo pricing

17:41 Apollo Studio and schema

21:18 Why we did this work now

26:34 Manipulating the cache

Sponsor: Jetpack Backup Stand-Alone Plugin

If the only feature of Jetpack you need is the backups, now you can install that as a stand-alone plugin and have a paid plan for that feature alone. Built and hosted on’s secure infrastructure, Jetpack Backup provides peace of mind — you can rest easy knowing that what you’ve built will always be there and can be easily recovered in an emergency.

The post 339: Apollo at CodePen appeared first on CodePen Blog.

Elsewhere: A brief introduction to Progressive Web Apps

Over on the Tighten blog I wrote up an extensive introduction to Progressive Web Apps. Later in the series I’ll actually teach you how to create your own. Check it out!

Within the last year or two I’ve watched references to service workers and PWAs, or Progressive Web Apps, go from never-heard-of-them to every-other-tweet. So! Let’s go learn. What is a PWA? What’s their history, purpose, and value? Why do we care?

Tighten Blog: A Brief Introduction to Progressive Web Apps, or PWAs