Gone are the days of pizza parties, mandatory company-sponsored bake-offs, or awkward company-wide happy hours at the local pub. Traditional office culture has gotten a bad rap in recent years, and with good reason – it can be stifling, exhausting, and downright soul-sucking. It’s no wonder that [millennial participation in the traditional workforce continues to decline](https://www.linkedin.com/news/story/is-gen-z-dropping-out-of-workforce-5059609/?lipi=urn%3Ali%3Apage%3Ad_flagship3_pulse_read%3BVE%2BSeoSmQPSuTsUmy9LAcA%3D%3D).

There’s a new kid on the block that’s giving office culture a run for its money: remote work. With flexible hours, the ability to work from anywhere in the world, and a more relaxed dress code, remote work is nailing culture in ways that office life never could.

Here are just a few of the reasons why we believe remote work has won the culture war.




## What even is company culture?

If you Google “what is company culture?”, you’ll get answers ranging from “clan culture” – one which encourages participation and company-wide commitment to success; to “caring culture”, which values creation of a welcoming environment. Essentially, it’s all the aspects of a company that make it a unique and desirable place to work.

The problem with culture is that many companies try to do all of the above – and they often fail at them all. Culture can’t just be a checkbox that has got to be ticked so it can be listed as a benefit on job postings. 

HR at your office job might tell you culture is created by playing awkward icebreakers before a meeting (bonus points if the meeting could have been an email), but in reality, it is so much more than that. 


hiker.png

## Work-life Balance
What better way to nurture positive culture in the workplace than encouraging your team to have a life outside work. How often have you felt pressured to put in a couple more hours at the office, or nervous to ask for time off? 

A culture that encourages work-life balance is a focal point of many remote companies. After all – how many other jobs are there where you can wrap up your work day at 5pm, hop on a flight, and start work the next day in an entirely new country. A culture that promotes work-life balance gives you the opportunity to not wait for vacation time or holidays to take your next adventure. 

water cooler.png


## The Water Cooler Chat vs. Slack

The water cooler chat – those generic “office culture” stock photos weren’t lying, these are actually considered a critical part of office culture. What’s not to love about catching up on the latest office gossip or chatting about your weekend while you fill your Hydroflask.  

Save yourself the walk over to the office kitchen. Say goodbye to the water-cooler chat, and say hello to Slack channels. We can only speak for ourselves here at Clevertech, but we take full advantage of being fully-remote, and love sharing our adventures, hobbies, and passions with eachother. With Slack channels for photography lovers, globe trotters, sports enthusiasts and more, you get to join the conversations that you choose to join – consider it your own custom tailored water-cooler chat, for every topic you’re interested in.





## A Culture of Trust

Nobody likes their boss breathing down their neck, especially when they’re peeking over your cubicle’s walls (you read that right, some people are still stuck working in cubicles if you can believe it). Remote work relies heavily on a culture of trust – you’re on the team because you’re the best, so your your employers knows that if you’ll say the job will get done, it will be done. Whether it’s trust to try something new, or to work on your own schedule, knowing your company believes in you is a big morale boost and cultivates a positive culture.


## Skip the awkward staff parties

Let’s be honest, nobody wants to sacrifice their night for an awkward company wide happy hour, and there are plenty of ways we’d rather spend our holidays than small talk at the office Christmas party, 

When you’re remote there’s no need to pull the “I’ve got to pick up my aunt from the airport” excuse to avoid awkward company gatherings – you’re celebrated in the ways you actually want to be celebrated.

For example, Clever Night Out is Clevertech’s way of celebrating as a team, without the meet-up. Our team can take their loved ones out for a night, on our tab. Because let’s face it, you’d probably rather spend a night out with your friends than with Steve from accounting. 


## Our final thoughts

We may be biased, but remote work is winning the culture department. After being remote first for over 20 years, you can’t blame us when we say we’ll never be going back to the office. If you’re tired of the same-old-same-old of office culture, remote work might be a fit for you. 



## Think Clevertech is the right place to start your remote-work journey? Drop us a line.

large_Remote desk.png

medium_Remote desk.png

small_Remote desk.png

thumbnail_Remote desk.png

Remote desk.png

small_desk1.png

thumbnail_desk1.png

desk1.png

Office Culture is So 2019: Here’s Why Remote Culture is Taking Over

When working directly with external remote customers, it can be difficult to build trust and manage expectations. All communication happens asynchronously and your interactions can sometimes feel like performing surgery over a walkie-talkie.

How do you know if you’re delivering what is expected of you?

This isn’t achieved through a strict set of rules, but by fostering a mindset that will help you navigate the waters of your new reality. 

Consider for a moment if you paid a business to perform a task that should take a day, but a week goes by and you don't hear anything from them. How does that make you feel? What if, without the result from that service, you lose profit and have customer dissatisfaction? Even more frustrating, when you reach out to them, you find out they didn't even start servicing your request because they are blocked by a simple issue you could have offered a solution for within a 5 minute conversation! 

We have all most likely experienced this before on some level and you probably didn’t return to that business again because of the poor customer service you received. After all, how can you trust them again in the future?


Provide the customer service you'd want to receive

cl2.jpg

Always have a discussion with your client on -
What their expectations are in terms of deliverables (how do I know I solved your problem?)
Time-sensitivity (is this for today? Is this for next week?) 
Priority (I'm already doing X, should I stop it in favor of Y?). 

Try to imagine the process of the service in your head and come up with questions about edge cases. Ask all questions you think of even if you think the questions might not be applicable. Do not start working with unanswered questions and don't be afraid to ask for confirmation during the process. Which service would you prefer - someone that communicates effectively with you to make sure they get it right the first time, or someone that pretends they understand, unwilling to ask questions, only to underdeliver and waste your time?


When working with remote customers, try imagining yourself as the company.

If the expectation was set that a task would take a work week to complete, send an update to your client on where you are with that task on Wednesday to let them know if everything is on track or if you feel that there are any unknowns that might delay the Friday delivery. This is also a great time to proactively ask around for people who can offer help to you if needed.

**Tip:**

If you're a software developer using GitHub, one fast/easy/cheap way of providing visibility on your progress is to open a Pull Request in Draft mode (you can select it on the little arrow next to the Create pull request button) immediately as you start working on the task, and commit all your work to your remote branch. This will both keep your work safe outside your PC, act as a flag that it's in a Work In Progress state, allow your colleagues to help you asynchronously by making early reviews, and let your (technical) clients check-up on you without having to ask you for status.

Frequently update those who are waiting for your work

cl3.jpg

You've spent 2 hours stuck on something. Your research and attempts have all led you to a dead end. You’re determined to find an answer because you're a professional. You feel this is your sole responsibility so you spend 3 more hours trying to find a solution. There is a better way! What matters for your client is that the delivery is made on time.Your deliverable won’t be any less effective merely because you had help. Everyone needs help sometimes. Reach out to your team as soon as possible. Ask for someone to pair up with you if that's what it takes to get you back on track.


Reach out when you get blocked

Your client has problems they need to address and oftentimes they are “telling” you what solution they think they want, but it may actually not always be the best solution you know they need. How do you get them to take your advice? You can build trust with your client by taking a genuine interest in their business and what they are trying to achieve. Over time, this will allow you to propose better alternative solutions that fully address the client’s needs. This can be difficult to do when first starting on a new project so stay alert to the client’s strategy and pain points. Proactively ask questions to understand what their true goals and needs are in the long term. Build trust by meeting deadlines, following through with perfection on the small projects, and communicate effectively on a consistent basis.

Whenever in doubt on how to proceed or how people might perceive your work ethics, look at it from the perspective of one where you are on the receiving end of the service.


Don't sell the product, sell the solution

large_cl1.jpg

medium_cl1.jpg

small_cl1.jpg

thumbnail_cl1.jpg

cl1.jpg

Written by:
Filipe Gorges Reuwsaat, a Senior Golang Engineer.


Visibility and Impact on the Client Project

Well, this is a little controversial, but it comes down to words like **passion**. The gems are the ones that **live and breathe software development**. Unfortunately, those passion driven developers are not always all that good at selling themselves. So, how can you shine? 

### The question that usually uncovers a true gem is, why did you get into tech? 
There are as many answers to that question as stars in the sky! Lots of times though, people tell the same story of staring when they were a kid and liking it ever since, but that doesn't work! It’s the authenticity and details of the answer that unveil the hidden gem. Saying you started developing at 9 is not a story, you need to get specific and even talk about feelings. What was it about developing? How do you feel when you rae working? What is YOUR story? Each developer who truly loves development has their story that has brought them on this journey.  Not everyone gets bitten by the development bug (no pun intended) early on in their lives either, what was the *ah ha moment* when you knew that this was your path, tell the story of that realization. Talk about real projects and real failures! If you can fail that means you are pushing yourself to your edge. Tell us what you learned, what you do differently now and why it makes you special. 




**Are you living and coding where you can grow, learn and be recognized for your unique solutions?** At Clevertech, we believe in **freedom, mastery and purpose.** Three elements that passionate developers appreciate and need to thrive. We aim to create an environment where developers can expand their skills and live their passion for development from wherever they want. **Are you ready to shine?**


medium_Gems.jpg

small_Gems.jpg

thumbnail_Gems.jpg

Gems.jpg

How to tell an interviewer that you are a gem!


Are You a Gem?

Clevertech truly cares about promoting and providing their staff with opportunities to continue growing in multiple facets of their lives. Our goal is to create an environment that supports personal and professional development for our Clevertechians all around the world. So from time to time we all meet and share some knowledge together. Here are some of the ‘Learn and Grow’ events we’ve hosted over the past year.

### How to Build a Modern Website in 2021 with Kent C. Dodds

Last October, Kent C. Dodds gave a presentation on the process of building a complete rewrite of his website. Using the latest and most modern tech, including React, Remix, Prisma, Postgres, Redis, Fly.io, Tailwind, TypeScript, and more, Kent takes us through some of the problems and decisions he faced while creating this new modern website. 


### Financial Planning with Brian Feraldi

Curious about what to do to set yourself up with a secure financial net? Want to learn more about how to invest your money smartly? Our Clevertechians had the opportunity to sit down with [Brian Feroldi!](https://twitter.com/BrianFeroldi?ref_src=twsrc%5Egoogle%7Ctwcamp%5Eserp%7Ctwgr%5Eauthor) A writer for the popular financial advice company [The Motley Fool](https://www.fool.com/), to learn about investing and how you can develop financial wellness.


### Design Systems with Dan Mall

We had Dan Mall with us to shine some light on our amazing designers. Design systems are tools to help developers make great products and this has left designers worried about their place in the design world.  Dan shares with us an overview of design systems, exercising the advantages of gorgeous art direction and the new role of designers in a world with design systems. 


### Choices of High Performing Teams with Dr. Laura Delizonna

As a company that takes on world-class projects with high-performing individuals, it is important that we make the right choices as a team on our road to success. 

We were lucky to receive insights from [Laura Delizonna, PhD](https://delizonna.com/team/) - a Stanford instructor, internationally renowned keynote speaker, and author of four books **Enhancing Emotional Intelligence, Mindful Leaders, Thrive, and Mindful** to learn about psychological safety, leadership effectiveness, emotional intelligence, and wellbeing. Dr. Delizonna emphasized one of the choices teams make on their road to success-Courage. It takes courage to be vulnerable, admit a mistake, or even repair a relationship. We will definitely be using Dr. Delizonna’s tips in and out of the office.  


delivered-blog-the-70-20-10-learn-and-grow-formula-1.jpg

large_delivered-blog-the-70-20-10-learn-and-grow-formula-1.jpg

medium_delivered-blog-the-70-20-10-learn-and-grow-formula-1.jpg

small_delivered-blog-the-70-20-10-learn-and-grow-formula-1.jpg

thumbnail_delivered-blog-the-70-20-10-learn-and-grow-formula-1.jpg

Take a look at our ‘Learn and Grow’ events 

Okay yes, the quality of your work is important to Clevertech but most importantly we just like to have fun and connect with our staff all around the world. There is something really unique about sharing experiences with global team members from different countries and cultures; and what’s better than connecting with your fellow Clevertechians to have some fun after a long day of work. Here are a few of the ‘Relax and Connect’ events we’ve recently shared as a company.    


### We committed to ‘Discovering Wellness’ together in January 2022

What better way to start the year than with a Wellness Challenge! During the month of January our Clevertech community took part in the Discovering Wellness Challenge which provided physical and mental daily challenges. Through a community of support and encouragement we engaged in a month of health and healing improving ourselves and each other.


### We Baked with a Dan Beasley- Harling from Great Britain’s Got Talent

Okay, serious question, who doesn’t like to eat tasty food? It’s one of life’s greatest pleasures and an awesome way of connecting with others. We were delighted to host and cook with baking legend, Dan Beasley-Harling in a super fun event where he taught us and our loved ones how to make focaccia and ciabatta bread. YUUUUM!

### We got creative with our wine and paint night!

Art and drinks? SIGN ME UP! With remote teams spread out all over the world, it can be difficult to find ways to connect. That’s why we have to get creative! Clevertech hosted a wine & paint night with Nikki Fuchs Sausen, who gave clear instructions on how to paint masterpieces while sipping on some wine. Take a look at these Clevertech masterpieces.



### We had a Virtual Magic Show with Alan Hudson from Great Britain’s Got Talent

A bunny out of a hat? Card tricks? Can you guess our next social event? We were absolutely wow’ed by guest Alan Hudson who gave an unforgettable virtual magic show. YES! A magic show. Sometimes our team just needs a little bit of fun and we are more than happy to give our Clevertechians exactly what they need. 


large_1548357920228.jpg

medium_1548357920228.jpg

small_1548357920228.jpg

thumbnail_1548357920228.jpg

1548357920228.jpg

Clevertech's #Relax and Connect Events 

Working remotely can make staying connected a real challenge. We get it! At Clevertech, we make connecting a priority and we make it FUN. Working at Clevertech comes with a number of cool benefits (ask about our [#cleverswag ](https://www.clevertech.biz/careers)) 😉 but one of the coolest is without a doubt, **the events**. We aim to host a variety of events that allow our employees from all over the world to share a snippet of their lives with us and develop a sense of trust and community within our remote environments. 

## Below are 4 reasons we prioritize Community Events. 

### **Encourage Communication** 💬

Clevertech has a global remote workforce that spans across a variety of time zones. Working remotely can easily result in bad communication and working in silos. Clevertech’s virtual Community Events gets ahead of this by giving staff a chance to meet and interact with other Clevertechians. This communication encourages us to talk to each other regularly when working from home and improves collaboration and a sense of community.

### Ignite Creativity 🎨 

It is essential that staff bring a dose of creativity and innovative solutions to their problem solving. Feeling “stuck at home” can result in loss of creativity and fatigue from sitting in endless meetings. Virtual Community Events create a space where staff can bounce ideas off each other or take a step back and decompress after a long week. [Take a look at our #Relax and Connect Events over the past year](https://clevertech.biz/insights/relax-and-connect-events).

### Foster Learning & Development 🌱 

We tend to consume educational material that is aligned with our line of work or immediate interests instead of investing time in the areas we have knowledge gaps. The truth is that there is so much to learn and many areas in which we could all use some development. At Clevertech it is important for us to create an environment that supports personal and professional development. [Take a more in depth look of the ‘Learn and Grow’ virtual events we’ve recently hosted](https://clevertech.biz/insights/learn-and-grow-events). 

### Boost Motivation 🚀

While one of the reasons Clevertechians come to work with us is our #nativeremote work life, sometimes we can miss that sense of camaraderie that comes going to an office. Many times,  it is our coworkers who keep us motivated and on track. By giving our staff something to look forward to through a virtual Community Event we can motivate them to remember just how passionate they are about our company and the work they do.







Our Clevertech Community Events are just one of the many amazing benefits of working with Clevertech. If you would like to learn more about the benefits Clevertech provides to their people, [click here](https://www.clevertech.biz/careers). 

large_Halloween.png

medium_Halloween.png

small_Halloween.png

thumbnail_Halloween.png

Halloween.png

 Community Events: 4 Reasons why we have them at Clevertech

Written by: Igor, Clevertech DevOps Engineer 

If you work with Terraform on a daily basis, you’ve already struggled with using and managing Terraform Modules. Some say that it's better to have each module in a single repository because this makes it easier to version and deploy them to the Terraform Cloud registry. But when you have a ton of modules, things usually start to get out of hand. Others say that monorepos are better because all your modules are in one place which allows you to follow patterns and validations. Versioning is harder however because tags and releases wrap the entire repository which means you can't have single versions for each module.



Here at Clevertech, we started out using multiple repositories but ended up facing two major issues. The first was that we eventually had too many repositories; and second, each repository had its own patterns (e.g. variable naming conventions, documentation, applicable use cases). So, we decided to switch to a monorepo to store all of them. However this required us to use those ugly as hell Git sources in the modules, and (obviously) versioning was off of the table.


But, what if we could bring together the advantages of both worlds and leave behind the mess? Can we have a monorepo that still allows each module version to be unique? If you’ve made it here, you’re probably guessing that the answer is yes. (Imagine coming all this way just to confirm that something doesn't work, right?)

Now enters [Lerna](https://github.com/lerna/lerna), **a tool to manage JavaScript projects with multiple packages**. Many JavaScript projects like React, Angular, and Ember, use monorepos to hold their packages, so it would make sense that a JavaScript tool has been written to solve this kind of problem.


Lerna uses its lifecycle management to handle package (or module) versioning, and the only two things it requires are:
- Each module must have a package.json file with its package version;
- The repository root should have a lerna.json configuration file;


So, when you stop to think about it, we can use Lerna to version anything in a monorepo. We just need to put a package.json into it and it's done! But then the question becomes how do we use this with Terraform Modules?


First, we put the package.json inside each module so we can see how Lerna sees them. And as a bonus, Lerna can both list all the modules in the repository or list only the modified modules. This is super handy when you need to change only a part of a repository and don't want to build/lint/validate the entire codebase.
With this list, we first create the docs for our modules using [terraform-docs](https://terraform-docs.io/), and then we validate them with terraform fmt -check -diff (with the -diff option, terraform can warn us if anything is wrong and tell us how to fix it) and terraform validate. We also use [super-linter from GitHub](https://github.com/github/super-linter) to lint all the files in the repository, not only the terraform ones.


With everything done and validated, we’re ready  for deployment (this is what we were aiming for!). The process is triggered by running the lerna version command. ne of the main advantages to using Lerna is its lifecycle. The version command has three lifecycle scripts: preversion, version, and postversion. First Lerna will get all modified modules, track the commits of each one and determine what will be the new version, and then it will  run the preversion of the root folder. After that, Lerna will enter each module and run its lifecycle scripts. Here is where we send our modules to the Terraform Registry. To achieve this, we use the [Terraform Module's API](https://www.terraform.io/cloud-docs/api-docs/private-registry/modules). We gzip all files of the module together, create the version on TF Registry and upload the gzip. With everything uploaded to the TF Registry, we can now commit the new versions and generate GitHub releases for each module.

Looks simple enough? That’s because it is! We can do our work and let Lerna take care of the rest. This pattern can be applied to any monorepo you are working on, not only a JavaScript or Terraform one. This improves organization without the cost of lose versioning. If you want to see it all in practice, you can see working examples using Jenkins and GitHub Actions [here](https://github.com/igorbrites/terraform-modules) . And if you still have  any questions, feel free to open an issue on the example repository.


How to Use Lerna in a Monorepo to Deploy Terraform Modules

When I was a bartender in downtown Toronto, I had the good fortune to be surrounded by many successful people on any given day. It was not a fancy bar by any means but it’s location right in the heart of the trendy King St West made it a great watering hole for all types of people. Being from a small town of under 1000 people in Alberta I had a very stereotypical view of what a successful person would look like, the way they dressed, how they acted and all the media narratives of how they became successful. What I found however were many different people from many different walks of life that all found a way to find their success. It made me want to dig deeper. Now even though people found many different means to become successful, through business, construction, academia, etc. I was amazed by the fact that the way they approached their vocation was extremely similar. I have broken it down into three main categories.

## 1.  They take accountability
I like to call this ‘Taking the Blame’. They understood that it didn’t really matter whose fault it was, what mattered was getting the end result. Truly successful people don’t have the time or the energy to play the blame game. Or complain. Or justify. If someone on their team did something wrong, THEY didn’t train them properly. If there was a miscommunication, THEY need to make sure to convey what they want more clearly. If a client wasn’t happy with their work, THEY made sure that it was fixed to what they needed. No matter what happened or how much control they had in the situation it was on them. Now when I first started playing with this idea it was very easy for me to think “people on my team should take responsibility for their own actions” and “If I do that then I won’t have enough time to take care of everything”. Which is completely true. However, that is not what is important. What is important is the mindset. If I take the blame for everything then I won’t spend any time or energy figuring out who’s fault it is and I can put that towards finding a solution. Which is really all that matters. Successful people are problem solvers. Simple as that.

download (2).jpg

## 2.  They have clear and purposeful goals
What makes a goal clear and purposeful? To make sure a goal is Clear I like to use the acronym **SMART **goals:

**Specific**- Set real numbers with real deadlines. Avoid goals like “I want to make more money”. How much more? $1 an hour more? $200k plus more? And by when? Tomorrow? Next year? If we can’t see our goals, we will never hit them. It’s like saying I want to go north without having a compass. You may do everything correctly but if it isn’t in the right direction it is very unlikely that you will not get to where you intend to go.

**Measurable**– Make sure your goal is trackable. “Social influence” is not a measurable goal. “Help more people” is not a measurable goal. “Be Better” is not measurable. How do you know how close you are if you can’t track your progress? This is where motivation dies. Not because we haven’t gotten to the destination but because we have no idea how much longer we have to go. People are OK with bad news but HATE surprises.

**Attainable**– Work towards a goal that is challenging but possible. The easiest way to not be successful is by making goals that are impossible to hit. Mostly because we are all human and we need small wins to keep up our confidence and continue to push forward. On the way to success the vast majority of people haven’t failed, they’ve quit.

**Relevant**– It actually pushes you closer to hitting your goals. Spending a week designing the perfect business card will not develop the app you are meaning to create. Playing 2k will not make you a better basketball player. We all have the same 24hrs a day and how we use that time will determine every aspect of our life. When we truly know what we want we need to take the relevant steps to get there.

**Time-bound** – State when you will get it done. It doesn’t have to be right, or even close, but creating a deadline adds a sense of urgency. Don’t be afraid to put pressure on yourself, that is where things get done. A goal is just a dream with a timeline, and too many people’s dreams die in the land of “I’ll do it tomorrow.”

Every goal I create I take it through these 5 things. If it doesn’t line up it doesn’t mean I need to completely scrap it. Usually it just isn’t fully formed yet and I need to go deeper into what I actually want and exactly what that looks like.

## 3.  They have long-term vision, and short-term focus

creating-a-sales-vision.jpg

Have you ever looked at one of your goals and felt like it was such an insurmountable undertaking that you just quit? Have you ever been so deep in the grind that you have forgotten what it is for and burnt out? This is why both of these things are important to have. If we want to truly be successful it is going to take a lot of time and a lot of work. And while we are doing this work, we need to know what it is all for.

To do this I like to break down my big goal into the smallest increments possible, usually into daily tasks. For a simple example, if I am selling a product where I have a net gain of $500 per sale and I want to make $100,000 this year. That means I have to sell 200 of these products. Now if I want to have my weekends off and take some vacation, I would have 250 working days in the year. That means I would have to sell an average of 4 products a week or 1 product every 4/5 business days. Now what are the DAILY actions I would have to take to sell 4 products a week? Obviously depends on the product and industry but let’s say I would have to present to 5 Qualified customers every day. Now how many qualified customers would I have to speak to so that an average of 5 would listen to a presentation? Let’s say 10. Then how many people would you have to contact to get an average of 10 qualified customers. I think you get the point.

This obviously takes some time and work to get it right but when we are able to break down our long-term vision into daily tasks that we can focus on this is where the magic happens. We start gaining momentum, our confidence rises, and we start to see progress towards our big vision. In time this creates a positive feedback loop where we gain even more momentum until our vision all of a sudden doesn’t feel so big and we can start creating even bigger goals.

Regardless of your experience and background, success doesn’t depend on luck or coincidences. By taking accountability, setting S.M.A.R.T goals and having a long term vision with short term focus - you can start to see progress towards your personal success.

large_getty_495142964_198701.jpg

medium_getty_495142964_198701.jpg

small_getty_495142964_198701.jpg

thumbnail_getty_495142964_198701.jpg

getty_495142964_198701.jpg

3 Qualities of Successful People

Written by [Matias Hernández](https://twitter.com/matiasfha), Full Stack Developer

You may already know that Typescript can be a significant improvement for your Javascript developer team, but, like any new language, there is a learning curve to harness its full power of it.

In this article, I will drive you through some advanced usages of Typescript that can help you achieve those data requirements or features.

> If you are looking for an in-depth guide to help you understand the Typescript reasoning and why you should choose it for your project, check this previous article: [Why we choose Typescript all the way through](https://clevertech.biz/insights/why-we-choose-typescript-all-the-way-through)

## What will be covered
We're going to explore several "advanced" building blocks that allow you to harness the power of the Typescript's type system. These types and features will enable you to enforce complex compile-time invariants.

- Generics
- Union and Intersection Types
- Typescript native utility types
- Mapped Types
- Template Literal Types
- Conditional Types

The principal value proposition of Typescript is to add some rules and order to a very loose language as Javascript leveraging the power of a compiler to act as a line of defense to catch data types related bugs. Static typing enforces contracts, which prevent certain classes of defects.

Let's dive directly into this.

## Generics
The main idea of the concept of **generics** is to allow you to create reusable pieces of code that can work with a variety of types rather than be restricted to a single one.

You can consider **generics** as code templates that you can define and reuse through your codebase. Its use will provide you with a way to tell functions, classes, or interfaces what type they should use when you call it.

You can even think of the **generic** type as an argument of a function.

You should strive to use and create a **generic** function when you need things like:

- A function that can work with different data types
- Use the same data type in different places

Let's see an example use case to when and why use **generics**

Suppose you need a function that randomly returns an element from an array.

This function accepts an ```array``` of type ```number``` and returns a ```number```. All good here, right?.

Now, let's assume that you also need to get a random string from an array of strings. How would that function look?



Precisely, the same. The only difference is the type of argument. In the first case, you used ```number[]``` and now ```string[]```.

How can you consolidate both functions that, in fact, have the same logic?

One option is to change the type of the argument to be ```any[]``` but, by doing this, you will lose the type checking powers that Typescript gives you, so it is not a good solution.

The other option is to use generics, here you'll define a "type variable" that will capture the type provided at the time of calling the function, like:




> By convention, typescript community uses single uppercase letters to declare the type variable, in this case, ```T```. However, you can use any word to define it.

Now, let's call this generic function with different types.

This example explicitly passes the array type that the function uses with the ```<>``` syntaxis.

In practice, the compiler will use type inference based on the argument, meaning that Typescript will guess the type of the generic based on the information from the argument passed to the function.

You can also use multiple generic parameters with **generics** by using different letters/names to denote each type.


## Using generic constraints to limit types
You may want to create a generic function (or interface or class) that can accept different types but only from a subset of types. In other words, you want to constrain the types that can be used for the generic.

To accomplish this constraint requirement, you'll use the keyword extends  that in effect allows inheriting functionally from a base type or class.

Let's use the same function as before, but let's say that you only want to accept arrays of strings and numbers.

Using generic constraints to limit types

## Union Types
A **union type** (or just "union" or "disjunction") is a way to define a mutually exclusive type. It is a way to create a value that can be of more than one type at a time.

This type provides information to the compiler that helps it to prove that the code is safe for all the possible data types passed to it.

This type is a perfect fit when you know all the possible states will be but do not know for sure which one will be used at a certain point. One everyday use case for this type is defining a dispatcher's actions like in the reducer pattern (like Reduce or ```useReducer``` in React).

Let's think in a promise, a promise can be in 3 states, ```pending```, ```fulfilled``` or ```reject``` you can model these states like





In this example, there are 3 interfaces: ```fulfilled```, ```Rejected``` and ```Pending``` that model the 3 states of the promise, then there is a type declared named ```RequestState``` that states that it can be any of the 3 possible states (one at a time).

Finally, in the function ```doRequest```, the request is performed, and a state is stored in a variable named ```state```. This ```state``` is then return by the function so in effect ```doRequest``` return type is ```Promise<RequestState<MyData>>```.

Then you can use this in another function and just ```switch``` over the state of the request by accessing the ```state``` value here. Typescript will ensure that you cover all the possible causes.

[Here is the Demo](https://www.typescriptlang.org/play#code/JYOwLgpgTgZghgYwgAgLIE8Aicx2QbwChkTlgATALmQGcwpQBzAbmNJDgFsJq6GQWhAL6FRoSLEQoAYgFcANvOnBFEcgB4AKgD4CbEnRw9kAchqyESGjROtSycjjjVNAbQC6d0tCgB7KAD81CAQAG7QrCKE4tDwSMgAShAAVhAIkOR69oaQ1CZQKWkZJgA0+g5OQcgh4VBeJD7+1ACiUH5QwqLR4LFSyAAKECDkTFmkOcYmAA5DIwKl5Y64VTUR5Y2BwWFrUWDoM4kQAI6yEHQAyriQWroAvMhyisqqGjrIAD6HqelqHwOzTFEMFkIHSwF8IFoEDAlyMNwAFKBgGBgHB5NQkiczjCrhAbgBKMYkeTQ2i45D3JEotHlYGglEQ5CyKZLCCwyDwkIAd3ZxkxpwuuIJRPsZKMFOqEB5uPKQmQ5QKYFkUEhRFF41xZXVJGZrN5ss6ojgNHQoOQdLBjPIvn52PhhLVpAQELoBAmJSZLKMvLl9xo0N56gw2Fw2nh+DFuVMM2GTBMQnx5Xo6BF9mdIFdBXM8jAErgXLgyPN0IQAAt4SYAPQ0XzcAC0yvkJkT2s9etx4fKrYmeXMljONi1rdIS2cyHzhdzWYUYAAdMkayB7V3SAnZQgcGX4RsHSudV7ILzO8ONUY8gVvsUhyeNtQNuOaMhWu098g1-YovZFcrIRNRFFjVNBBzRBS1IU4Qsl13NMXSnM4ZzzAsi2tW06GXbIuWRLdpxzWcJmg7UN39aMAXmShX3sNFoDACtUNzYBH0GWN5nxephwAIwKOAAGs2LTY0UDMCwrBsciTxIKioBokwAEFFGQRhfF8chmz47VOIgHi1JIIjBIvIo1BMMTxMkmiAAMAElc3gFQ1GoAASfAcLnDZZ24aw4EYCAhDMltxI0rSDSEIA), go ahead and try to delete one of the switch cases. What happens?

Another common use case of an **union type** is found in the DOM itself. DOM events always happen independently of each other. So there is a finite list of possible events that can be processed:


One particular case of union type is **discriminated unions** (or tagged union). This specific case allows you to easily differentiate between the types with it.

Why would you want this? Because a union type can also host different types and sometimes you will want to know what type is in use, you can always use type guards for this purpose, but there is a shortcut: **discriminated unions**.

To create a **discriminated union**, you need to add a specific field to each type in the union, differentiating between each type.

One everyday use case for this type of union is to check that one piece of the data is present while another part is not. For example, A user account should have ```username``` and ```email```  and include an ```avatar``` OR an `emoji.

To model this, you need to combine different types to define each case and use optional attributes along with the ```never``` type like this:

[Here you can find the Demo of this code](https://www.typescriptlang.org/play?#code/C4TwDgpgBA6glsAFgVQM4QE4DsCGBbaAXigG8AoKSqAV3W3wgC4pVgM4sBzAbgqojw44AGwD8zLBABumMgF8yZUJFgJEAUUEioxclRp1cBcVEkyMvfQKHDmrdl14Kl4aPCQBBKTmA4MO0j5KAQB7ACs4EzNMSyocb18MOzYOTnlFZTc1TXC4AL1+PFzkhx4gqHifPyjpWWcM1yg0THyoOAATCWo8ACMWuSgAMigACncUQwYoAB9VJE0bAEoh0fGvKv9Z8ZyIxcUAYxCsVgNMcYA5Bg8sdvXE5mb-XTbOqABGABpT+gJmAHJaJgjBA-l9KvcoH9wX4-lBnIdjsBvtstMJrrcEn4HnRWh1mAAmL7WET-YnCUEVTFJSHQjB-eFHE6AjAXK43HZwbEtZ54qAAZi+zOB-yFDApoQipKKEVhDMRyOyqPRHK5T1IL2YABYiaipTZxdLOZCJXB6QdGUiAO4YI6cR6q3GdACsgsmv0hooIBpsepEBuKxsNZrICJO1ttj3xDp5ztdQIYIrdIJ1Ab+JoptP+tL+AAK5EA)

To implement the above requirement, there are 4 types that work in pairs to describe what attribute should be present and how the other attribute should be.

Then a new type is created as the **union** of the other ones.

Then the new type is used, and Typescript will tell you if you are using the wrong combination of attributes.

Union types are an excellent modeling tool. There are good reasons to not use them:

-  When the types are known at compile-time: You can use generics instead to provide further type safety and flexibility.
-  When we need to enumerate all possibilities at runtime: Use enum instead for this).

Union types are an ergonomic way to model a finite number of mutually exclusive cases, allowing you to easily add new cases.

> By combining this feature with mapped types, you can even dynamically create types as shown in [this great Demo by Matt Pocock](https://twitter.com/mpocock1/status/1498284926621396992?s=20&t=w7tdOotYWM4IEic_NdqGOQ) that transform a union type to another union type with a different shape.

## Intersection types
**Intersection** types can be considered the opposite of the previous **union** type.

These types create a new type by **combining**  multiple existing types. The new type will have all the properties and features of the existing ones.

When you are intersecting type, the order doesn't matter.

In summary, an **intersection** type combines two or more types to create a new type that includes all the properties of the existing types.

## Typescript native utility types
Typescript provides you a handful of handy utility types that helps to manipulate types with ease. These utility types are, in fact, generic types.
### Partial
This utility type will enable you to create a type that will set all the properties of the exiting type to be optional.

### Required
It is, in fact, the opposite of **Partial**, marking all the properties of a type as required.

### Readonly
This type will mark all the properties of the type argument to be not-reassignable or **read-only**

### Pick
You can create a new type by "picking" properties from an existing type.

This type allows you to create new types from a previous one by describing what properties you want as the second argument of the generic parameters.
### Omit
On the other hand, you have **Omit** that works as the opposite of **Pick** by allowing you to select what elements to remove or not consider when creating the new type.

### Extract
This type will create a new type based on the properties present in two different types. It will **extract** from the type **T**  all properties assignable to type **U**.

Let's see an example. Here the goal is to extract all the arguments that are function types.

The first argument we pass to Extract is our union type, and the second argument is the type that we will use when comparing each union member. If a member is assignable to our second argument, it will be included in the resulting type.

But, how this looks like in real life? A good use case will be creating a filtering function.

Say you have an array of users with different types of users tagged by the ```type``` property, so you have a **discriminated union**  as a type.


Now, you want to create a function that takes an array of ```Users``` and returns only those that match a specific ```type```.

You can quickly get away with something like this.

But, there is a minor issue with this function (even though the result will be correct at runtime), the return type of this function will always be ```Users[]``` even though you know for sure that the result will be just one of the types.

Let's use ```Extract``` to create a better return type.

This seems a bit more complex so let's dissect it.

The function accepts two generics and uses a type predicate inside the filter function, allowing you to instruct Typescript about the specific type of the argument passed to the function when the function returns ```true```.

The type that the filter function will narrow is ```Extract<T, Record<"type", U>>``` where ```T``` will be the ```Users``` array and ```Record<"type", U>``` will be an object like ```{type: 'affiliate' }```

So the end result of the filter will be ```{type: 'affiliate', program: string}```

### Exclude
This type works opposite to Extract by excluding properties already present in two different types. It excludes from ```Tall fields that are assignable to U```.

### NonNullable
This utility type will take a Type ```T``` and remove ```null``` and ```undefined``` from the allowed type values.

useful for instances where a type may allow for nullable values farther up a chain, but later functions have been guarded and cannot be called with null

It is important to note that this utility is not recursive. If you have a type with a nullable property, using the higher ```NonNullable``` will not affect the property. You'll need to overwrite the base type/interface to do so.

There are a few more utility types that allow you to perform different tasks like:
- Parameters: Create a tuple type from the types used in the parameters of a function
- ReturnType: Creates a type from the return type of a function.
- String manipulation types: Uppercase, Lowercase, Capitalize, and Uncapitalize. These utility types allow you to manipulate strings transforming string types.
## Mapped types
It is time to review a feature a bit more complex. **Mapped types** allow you to take an existing model and transform its properties into a new type. This handy feature allows you to keep your types DRY.

The first step to understanding this type of [metaprogramming](https://en.wikipedia.org/wiki/Metaprogramming) is to know why you want to use mapped types.

The primary use case is when you need to create a type derived from another type and remain in sync with the original one.

For example, a permissions schema defines an object that stores the user's permissions to change configurations in the app.

What happens if you add new configurations to the schema? You'll need to also update the permissions type to accommodate the new configuration on it.

In this case, would it be way better to have types that rely on each other to keep them in sync, decreasing the maintainability effort?

How could this look?

This example combines several features of Typescript, it uses:
- Indexed access types: You can access the property type by looking it up by name.
- Index signatures: Allow you to access a property even if you don't know the name of it by using the ```[]``` syntax (like you usually do with dynamically accessing an object property in javascript)
- The keyof operator: This operator returns a union of the keys of the type passed to it. In this case, the use of ```keyof Configuration``` resolves to ```"layout" | "withdraw" | "deposit"....```
- Capitalize An utility type that transforms a string into the capitalized version of it. In this case, it changes the ```Property``` name: ```layout``` → ```Layout```.
Finally, it uses [template literal types](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html) to create the name of the new property. This is a feature name as [key remapping](https://www.typescriptlang.org/docs/handbook/2/mapped-types.html#key-remapping-via-as).
## Template Literal Types
These types are built on the [string literal types](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types) adding the ability dynamically creates a string.
It uses the same syntax as javascript template literals.

But the real power of this type comes when you need to define a new string type by deriving its value from the information inside the type.

Let's use template literals to extract and manipulate a string literal type to, in turn, use them as properties, let's start by splitting a string to an object.

Imagine that you want to check if a semver string is in the correct format. You know the semver pattern is like ```Major.Minor.Patch``` so, let's build a type to check that pattern and at same time split that into an object for type checking and autocompletion.

[Demo for this code](https://www.typescriptlang.org/play?#code/MYewdgzgLgBAbgUwE4QJbhgXhgIgCwB0AjAQEw4CwAUFAJ4AOCMAasmhtnYyAGbxvow1agHoRMAOpNgAQzAxgSBDKhMZMLkyggYCAB5QkM4LCgALaSAC29cAjBQIMXhrMqY0JKjABzAqPEpAHIAGxCPehDUWGMkEAgnKAB3HSCCIIU3IxM2fyoAmAAxVBRYEIRoIKd9Q2NTCwVrWzB7R2c+cyZPbx8AGhgkpgBrMBAk13cIBCtEJBh6FVUkeQLUJyihpgBZGVoQJAIt732CAAUVYDMYAvM1mBkQiB0AVyn7xrAAE2jBB40GLRuWB3fSRGTeBCfGAAIwQITGBT2zwUchgShkUOi9ycAANUHwAMrTWYweEgIbrVCbVx3BZQJbyTryCCRLHebT3eQgaEAKwQJl0jyYyDiSGENABMAAogZslAiTNkAAeBUkmr2T5Obq+AB8WGoMENMFVyF0Bg1uIAJABvbw8U07Hn7AC+BBtdodxyQrvdYHtc3OUEuzpxMAA-AajdaYFYZE6kAAuGCO-b9KxepNHUZIfp0y5JwOXGDOmBJyOG6Mi-ZJnAAYTko1gCxQXWJpu1PhwxfF1E0MAASggAI7PEqQ1goQRYaWyuompBKifsMA6nsSxjGttIKVIUXTmW1EzzpU4QogZ5zWzsmAALWQOivDiKqEQOD1YhgABUGnAHs8mCA9B8Di847qKoZ3HWDYgE2Mgth4W4eIYPSUFQQA)

First step is to get the string ```version``` into a type by using ```typeof```. Then create a type to hold the extracted semver pattern.
First step is to restrict the generic ```Semver``` to be an string, then at the right side a conditional type is defined (explained below) that check if the pattern match, if so, then the pattern is split into an object. If the condition fails, then an error is stored.

There are many other powerful applications of this features, for example:
- A JSON parser with type safety
[Jamie Kyle 🏳️‍🌈 on Twitter](https://twitter.com/buildsghost/status/1301976526603206657)
- A dot notation getter with type safety
[GitHub - ghoullier/awesome-template-literal-types: Curated list of excellent Template Literal Types examples](https://github.com/ghoullier/awesome-template-literal-types#dot-notation-string-type-safe)
- A CSS Parser that you can toy around [in the typescript playground](https://www.typescriptlang.org/play?#code/C4TwDgpgBAKgTgSwLYHUAWDgQMpgIYDGEAPNsHFBAB5YB2AJgM5SPkK0DmAfFALxQAoKCzadKNCA2Zk4QqAH4oAIgCicOAHs4SuQC4oM8XSZQABlAAkAb3YAzCBRkBfcwB8zAHVrW7Dg+Rc5RXhkdEwcfCJSch49f1kBUEgoAHEIYBhwEkNqY2ZWRE4efjkC9g4jSRMZIOU1TW04nIkpMx9aewoANTwAGwBXCCcwKlNa2n6kACM-OLLOAG4BRKyoAAU8OEYIAGFsbDXNMEZSStb57j5BYWwzk1N2zvWjp11Hvx6BoYX3igAlCCsQLCYSKKxyEFQADaAGsoOxYIhUBgsLhCCRDhowFwALr6NIZLLEELI8JoqKfQZcLgQqBOKAAMnWm22ewORxOANYNMh+n6tBhtA0AHdaMsVskCVzgGziNK7vlRJcSsISWFUZESNKeLkqswHjYOn4dhpaHRgE4nL8oH9pS5rgobfK4tKlhLoBsthBpbL5brzkrinI1SiIui5YDgDqWvdrSazZILVbDU9bZHgY7Paz9pjjsR4+aeVB9Bc3UkPSzdvtTv6TBcg8ILgqDLVVOotDphPoQ2TNaRo3k2injb08IxGAA5PBIIZQKzWu3mWrgyGw+G0RGhUPkkg7Ufjqcz3H6LPeyO+yNF+nuU+yqXn6vanglpVl1ZszKQZj8W-VsbCKYNHoEA5wdYQkDwKgAFphQQehgDQfQACYAAYRiWSEpkIGEOE0fl6CgggNF6LR9F6BAODQYApi+DC6WWYQADo0AARjnWkiJIuB9GFUM6KcBioAAYjAdjIVsU1gCg2xpwQXoQH0AA3Bx6DwWg8Do4QJLNKDGAQAAvCBkLQqh+IEUwaWWIjaFYKA+l6P4KKo-QPyyb8xKgQDgP0KxlCwggcLwhhCOIjt9CUOAIHoJQABplAg6DYPgtAlH0FiUJQukYrkJQRNS0ClG0qSZKQOSQHypRlLgVT1Ni5Qit0gyIHy9Kspy5iWPy3zONI5RePCJQ2oEgRrNs2Del6epetcr8rl8gB6ebnixBxQCgAByJQEpguCEKUdb4WYUrx3Kdc5C8hSCv8wKNHwkKuIqyLora4RcrALr6sk6TZPkiqqpqvA6sKr69MMlrMqcbLXo6j6eu4vrQ0GyGBCcIA).
- And many more that you can find in this [awesome repository](https://github.com/ghoullier/awesome-template-literal-types).
There is also a few collection of utilities that help you to create even more complex types, one of them is [ts-toolbelt](https://millsp.github.io/ts-toolbelt/) that provides hundreds of utilities.

[Here you can find](https://twitter.com/mpocock1/status/1499002040168636420) a very cool use of the utilities of ts-toolbelt and string manipulation. (video by Matt Pocock)

One of the utilities used in that video and provided by ts-toolbelt is ```Split```. Yes, you can construct a type that let's you split a string literal and transform that into a list of string literals to then use it as type.

Let's see how to build a simplified version of it

[Check the Demo](https://www.typescriptlang.org/play?#code/PTAEEkBdQdwSwDYNAQwMZoKYAdqRgPaoBOA5gK4C2mAdpAM4A0okAFpqPZMXDaS0XrYEcaAAMAymNQ0AJqlCzMIyqJSQCxUGIAiYgFCQAntg4ThogDwTQmAB6Ras+p269SzHbYdOXXHnwAfKAAvPqgEa4B-PaOci42APxR7gDaALqgAFzhkTaxvqAA5EWgyRnZuRH5PvHaACQA3rwAZphaACoAvk06Pc00bVoAql3S5R3MAHQz5iKQlsOegZlZoKkS6QDc+rvGpqASAIyhhxYL-u7MAERT14G7hiZmAEync1bX1zd3wSAZj32ZgAzO9zpZrkcpi9vqBbvdQP9Id9rjD0ntnocACxg+YQqEvKbA2Hwv7AVLIxiolHE9FPA4AWRQACtNO8sakAAyZEDIoA)

First, it declares that the type will accept two "arguments", type ```S``` as the string to be splitted and type ```D``` as the delimitator, both should be strings.

Then, in the second line, it use a conditional type (explained below) that checks if the string is an string literal, if so it returns an string array.

Next line check if this string array is empty, if so, it returns an empty tuple, otherwise, in a similar way to the ```ExtractSemver``` example it checks if the string ```S``` matches the pattern and extract the pieces to then recursively re-run the ```Split```. If the string don't match, meaning the delimitator is not present, then it just return the ```S```.
## Conditional Types
Another powerful typescript feature is the ability to create a type based on a condition. This is, in fact, the description of a type relationship test that selects one of two possible types based on the outcome of that test.

It looks like this

That looks similar to the javascript ternary operator. You can also read this like this pseudocode.

Here the letters ```T```, ```U```, ```X```, and ```Y``` stand for arbitrary types.

The piece of code shown in the conditional part ```T extends U``` describes the type relation that is set to test.

Typescript uses this feature to create the utility types like ```NonNullable```. The code for that type looks like this

This type selects the ```never``` branch if the type ```T``` is assignable to either ```null``` or ```undefined```. Otherwise, it keeps the original type ```T```.

Let's check another example use case for conditional type. Imagine that you want a way to figure it out if a string is trimmed, meaning it doesn't have empty spaces at the end of the beginning. How can that be done?

Now let's see how to implement this type. Let's check if the passed string has empty spaces at the end. You'll need a way to say:

"Check if the string contains an at the end. This can be done by using the keyword ```infer```

The ```infer``` keyword is a compliment to conditional types. It cannot be used outside of an ```extends``` clause. ```infer``` allows you to define a variable within the constraint to be used or referenced later.

So in the previous code snippet, the type ```infer R```  is extracting the type of the ```T``` generic and, since it is inside of a template literal, is constructing a new string with an empty space at the right side.

It can be read as "Is T the string with empty space at the right"?

With that, let's create the type ```TrimEnd```.

So, this type accepts a generic that ```extends``` (is constrained to) a ```string``` . A conditional type checks if ```T``` is the string with empty spaces at the right side (this is done dynamically thanks to the template literal type).

If the condition is true, it passes the type again to recursively find a string that doesn't end with a space.

You need to check if the string starts with an empty space. That type is the same but opposite of ```TrimEnd```, let's call it ```TrimStart```

And with these two types, you can finally create the T'rimmed' type required.

[Demo for this code](https://www.typescriptlang.org/play?#code/C4TwDgpgBAKgTgSwLYGVgEM7ADwDUoQAewEAdgCYDOUlwipA5gHxQC8U+RJF1ABlABIA3glIAzCHCgAlAL78A-LESoMWbNJYAuDgG4AUKEjLkAUQp4CxMlRp1RzNhyvdb-YaIlS5ik0nPkGtp6huDQ8MhIEIGc1jx29I7sEaqYOCkBeExMBvr6AMYA9qS0UGDolJQA7oVw5E4ARFDAABYI1O3NLdDllTV1UFUIrQRIYKA05fkQ1OjAXdA2UOgUUABGEAyiUA15+mIArqT5wAjFUEUANpcQJwAKFdW1gTAuNtS0iUwAFJ86KVEXkwAJRQIT6KCQqBwCDAA5wUgJAyyPJXG73R79cjfBqtTqdVo9THPBrA1GFa63YAPPrPHFQUQAN3QlwQ9V6TwGpKAA)

This type uses a combination of powerful typescript features: Template Literal Types and Conditional Types. You can mix and match as many Typescript features as you need and want to create your own utilities and complex types.

Typescript is a fully-fledged language that is not just to add some types into the loosy Javascript but can help you model complex data requirements and avoid various kinds of bugs.

large_1_Dl2Twyg86r6m7lwU9sc6Tg.png

medium_1_Dl2Twyg86r6m7lwU9sc6Tg.png

small_1_Dl2Twyg86r6m7lwU9sc6Tg.png

thumbnail_1_Dl2Twyg86r6m7lwU9sc6Tg.png

1_Dl2Twyg86r6m7lwU9sc6Tg.png

We're going to explore several "advanced" building blocks that allow you to harness the power of the Typescript's type system. These types and features will enable you to enforce complex compile-time invariants.

Ionic Deploy: When Custom App Development Is Your Only Solution

How Custom Mobile Application Development Solved a Hard Problem at Clevertech.

Read all
our insights

Read all
our insights

Turn your toughest challenges into tangible business impact

Ionic Deploy: When Custom App Development Is Your Only Solution

How Custom Mobile Application Development Solved a Hard Problem at Clevertech.

Read all our insights

Read all our insights

Turn your toughest challenges into tangible business impact

Read all
our insights

Read all
our insights