What is ExpressJS and what are its top alternatives?
Top Alternatives to ExpressJS
KoaKoa aims to be a smaller, more expressive, and more robust foundation for web applications and APIs. Through leveraging generators Koa allows you to ditch callbacks and greatly increase error-handling. Koa does not bundle any middleware. ...
ReactLots of people use React as the V in MVC. Since React makes no assumptions about the rest of your technology stack, it's easy to try it out on a small feature in an existing project. ...
FlaskFlask is intended for getting started very quickly and was developed with best intentions in mind. ...
DjangoDjango is a high-level Python Web framework that encourages rapid development and clean, pragmatic design. ...
GolangGo is expressive, concise, clean, and efficient. Its concurrency mechanisms make it easy to write programs that get the most out of multicore and networked machines, while its novel type system enables flexible and modular program construction. Go compiles quickly to machine code yet has the convenience of garbage collection and the power of run-time reflection. It's a fast, statically typed, compiled language that feels like a dynamically typed, interpreted language. ...
NGINXnginx [engine x] is an HTTP and reverse proxy server, as well as a mail proxy server, written by Igor Sysoev. According to Netcraft nginx served or proxied 30.46% of the top million busiest sites in Jan 2018. ...
LaravelIt is a web application framework with expressive, elegant syntax. It attempts to take the pain out of development by easing common tasks used in the majority of web projects, such as authentication, routing, sessions, and caching. ...
hapihapi is a simple to use configuration-centric framework with built-in support for input validation, caching, authentication, and other essential facilities for building web applications and services. ...
ExpressJS alternatives & related posts
- Async/Await6
- JavaScript5
- REST API1
related Koa posts
ReactQL is a React + GraphQL front-end starter kit. #JSX is a natural way to think about building UI, and it renders to pure #HTML in the browser and on the server, making it trivial to build server-rendered Single Page Apps. GraphQL via Apollo was chosen for the data layer; #GraphQL makes it simple to request just the data your app needs, and #Apollo takes care of communicating with your API (written in any language; doesn't have to be JavaScript!), caching, and rendering to #React.
ReactQL is written in TypeScript to provide full types/Intellisense, and pick up hard-to-diagnose goofs that might later show up at runtime. React makes heavy use of Webpack 4 to handle transforming your code to an optimised client-side bundle, and in throws back just enough code needed for the initial render, while seamlessly handling import statements asynchronously as needed, making the payload your user downloads ultimately much smaller than trying to do it by hand.
React Helmet was chosen to handle <head> content, because it works universally, making it easy to throw back the correct <title> and other tags on the initial render, as well as inject new tags for subsequent client-side views.
styled-components, Sass, Less and PostCSS were added to give developers a choice of whether to build styles purely in React / JavaScript, or whether to defer to a #css #preprocessor. This is especially useful for interop with UI frameworks like Bootstrap, Semantic UI, Foundation, etc - ReactQL lets you mix and match #css and renders to both a static .css file during bundling as well as generates per-page <style> tags when using #StyledComponents.
React Router handles routing, because it works both on the server and in the client. ReactQL customises it further by capturing non-200 responses on the server, redirecting or throwing back custom 404 pages as needed.
Koa is the web server that handles all incoming HTTP requests, because it's fast (TTFB < 5ms, even after fully rendering React), and its natively #async, making it easy to async/await inside routes and middleware.
We are using Node.js and ExpressJS to build a REST services that is middleware of a legacy system. MongoDB as database. Vue.js helps us to make rapid UI to test use cases. Frontend is build for mobile with Ionic . We like using JavaScript and ES6 .
I think next step could be to use Koa but I am not sure.
- Components832
- Virtual dom673
- Performance578
- Simplicity508
- Composable442
- Data flow186
- Declarative166
- Isn't an mvc framework128
- Reactive updates120
- Explicit app state115
- JSX50
- Learn once, write everywhere29
- Easy to Use22
- Uni-directional data flow21
- Works great with Flux Architecture17
- Great perfomance11
- Javascript10
- Built by Facebook9
- TypeScript support8
- Server Side Rendering6
- Speed6
- Feels like the 90s5
- Excellent Documentation5
- Props5
- Functional5
- Easy as Lego5
- Closer to standard JavaScript and HTML than others5
- Cross-platform5
- Easy to start5
- Hooks5
- Awesome5
- Scalable5
- Super easy4
- Allows creating single page applications4
- Server side views4
- Sdfsdfsdf4
- Start simple4
- Strong Community4
- Fancy third party tools4
- Scales super well4
- Has arrow functions3
- Beautiful and Neat Component Management3
- Just the View of MVC3
- Simple, easy to reason about and makes you productive3
- Fast evolving3
- SSR3
- Great migration pathway for older systems3
- Rich ecosystem3
- Simple3
- Has functional components3
- Every decision architecture wise makes sense3
- Very gentle learning curve3
- Split your UI into components with one true state2
- Image upload2
- Permissively-licensed2
- Fragments2
- Sharable2
- Recharts2
- HTML-like2
- React hooks1
- Datatables1
- Requires discipline to keep architecture organized41
- No predefined way to structure your app30
- Need to be familiar with lots of third party packages29
- JSX13
- Not enterprise friendly10
- One-way binding only6
- State consistency with backend neglected3
- Bad Documentation3
- Error boundary is needed2
- Paradigms change too fast2
related React posts
I was building a personal project that I needed to store items in a real time database. I am more comfortable with my Frontend skills than my backend so I didn't want to spend time building out anything in Ruby or Go.
I stumbled on Firebase by #Google, and it was really all I needed. It had realtime data, an area for storing file uploads and best of all for the amount of data I needed it was free!
I built out my application using tools I was familiar with, React for the framework, Redux.js to manage my state across components, and styled-components for the styling.
Now as this was a project I was just working on in my free time for fun I didn't really want to pay for hosting. I did some research and I found Netlify. I had actually seen them at #ReactRally the year before and deployed a Gatsby site to Netlify already.
Netlify was very easy to setup and link to my GitHub account you select a repo and pretty much with very little configuration you have a live site that will deploy every time you push to master.
With the selection of these tools I was able to build out my application, connect it to a realtime database, and deploy to a live environment all with $0 spent.
If you're looking to build out a small app I suggest giving these tools a go as you can get your idea out into the real world for absolutely no cost.
Your tech stack is solid for building a real-time messaging project.
React and React Native are excellent choices for the frontend, especially if you want to have both web and mobile versions of your application share code.
ExpressJS is an unopinionated framework that affords you the flexibility to use it's features at your term, which is a good start. However, I would recommend you explore Sails.js as well. Sails.js is built on top of Express.js and it provides additional features out of the box, especially the Websocket integration that your project requires.
Don't forget to set up Graphql codegen, this would improve your dev experience (Add Typescript, if you can too).
I don't know much about databases but you might want to consider using NO-SQL. I used Firebase real-time db and aws dynamo db on a few of my personal projects and I love they're easy to work with and offer more flexibility for a chat application.
- For it flexibility10
- Flexibilty and easy to use9
- Flask8
- User friendly7
- Secured6
- Unopinionated5
- Secure2
- Customizable1
- Simple to use1
- Powerful1
- Rapid development1
- Beautiful code1
- Easy to develop and maintain applications1
- Easy to setup and get it going1
- Easy to use1
- Documentation1
- Python1
- Minimal1
- Lightweight1
- Easy to get started1
- Orm1
- Not JS1
- Perfect for small to large projects with superb docs.1
- Easy to integrate1
- Speed1
- Get started quickly1
- Open source0
- Well designed0
- Flexibilty0
- Productive0
- Awesome0
- Expressive0
- Love it0
- Not JS10
- Context7
- Not fast5
- Don't has many module as in spring1
related Flask posts
One of our top priorities at Pinterest is fostering a safe and trustworthy experience for all Pinners. As Pinterest’s user base and ads business grow, the review volume has been increasing exponentially, and more content types require moderation support. To solve greater engineering and operational challenges at scale, we needed a highly-reliable and performant system to detect, report, evaluate, and act on abusive content and users and so we created Pinqueue.
Pinqueue-3.0 serves as a generic platform for content moderation and human labeling. Under the hood, Pinqueue3.0 is a Flask + React app powered by Pinterest’s very own Gestalt UI framework. On the backend, Pinqueue3.0 heavily relies on PinLater, a Pinterest-built reliable asynchronous job execution system, to handle the requests for enqueueing and action-taking. Using PinLater has significantly strengthened Pinqueue3.0’s overall infra with its capability of processing a massive load of events with configurable retry policies.
Hundreds of millions of people around the world use Pinterest to discover and do what they love, and our job is to protect them from abusive and harmful content. We’re committed to providing an inspirational yet safe experience to all Pinners. Solving trust & safety problems is a joint effort requiring expertise across multiple domains. Pinqueue3.0 not only plays a critical role in responsively taking down unsafe content, it also has become an enabler for future ML/automation initiatives by providing high-quality human labels. Going forward, we will continue to improve the review experience, measure review quality and collaborate with our machine learning teams to solve content moderation beyond manual reviews at an even larger scale.
Hey, so I developed a basic application with Python. But to use it, you need a python interpreter. I want to add a GUI to make it more appealing. What should I choose to develop a GUI? I have very basic skills in front end development (CSS, JavaScript). I am fluent in python. I'm looking for a tool that is easy to use and doesn't require too much code knowledge. I have recently tried out Flask, but it is kinda complicated. Should I stick with it, move to Django, or is there another nice framework to use?
- Rapid development673
- Open source487
- Great community425
- Easy to learn379
- Mvc277
- Beautiful code232
- Elegant223
- Free207
- Great packages203
- Great libraries194
- Comes with auth and crud admin panel80
- Restful79
- Powerful78
- Great documentation76
- Great for web72
- Python57
- Great orm43
- Great for api41
- All included32
- Fast29
- Web Apps25
- Clean23
- Easy setup23
- Used by top startups21
- Sexy19
- ORM19
- The Django community15
- Allows for very rapid development with great libraries14
- Convention over configuration14
- King of backend world11
- Full stack10
- Great MVC and templating engine10
- Mvt8
- Fast prototyping8
- Its elegant and practical7
- Easy to develop end to end AI Models7
- Batteries included7
- Have not found anything that it can't do6
- Very quick to get something up and running6
- Cross-Platform6
- Zero code burden to change databases5
- Great peformance5
- Python community5
- Easy Structure , useful inbuilt library5
- Easy to use4
- Map4
- Easy to change database manager4
- Full-Text Search4
- Just the right level of abstraction4
- Many libraries4
- Modular4
- Easy4
- Scaffold3
- Node js1
- Built in common security1
- Great default admin panel1
- Scalable1
- Cons1
- Gigante ta1
- Fastapi1
- Rails0
- Underpowered templating26
- Autoreload restarts whole server22
- Underpowered ORM22
- URL dispatcher ignores HTTP method15
- Internal subcomponents coupling10
- Not nodejs8
- Configuration hell8
- Admin7
- Not as clean and nice documentation like Laravel5
- Python4
- Not typed3
- Bloated admin panel included3
- Overwhelming folder structure2
- InEffective Multithreading2
- Not type safe1
related Django posts
Simple controls over complex technologies, as we put it, wouldn't be possible without neat UIs for our user areas including start page, dashboard, settings, and docs.
Initially, there was Django. Back in 2011, considering our Python-centric approach, that was the best choice. Later, we realized we needed to iterate on our website more quickly. And this led us to detaching Django from our front end. That was when we decided to build an SPA.
For building user interfaces, we're currently using React as it provided the fastest rendering back when we were building our toolkit. It’s worth mentioning Uploadcare is not a front-end-focused SPA: we aren’t running at high levels of complexity. If it were, we’d go with Ember.js.
However, there's a chance we will shift to the faster Preact, with its motto of using as little code as possible, and because it makes more use of browser APIs. One of our future tasks for our front end is to configure our Webpack bundler to split up the code for different site sections. For styles, we use PostCSS along with its plugins such as cssnano which minifies all the code.
All that allows us to provide a great user experience and quickly implement changes where they are needed with as little code as possible.
Hey, so I developed a basic application with Python. But to use it, you need a python interpreter. I want to add a GUI to make it more appealing. What should I choose to develop a GUI? I have very basic skills in front end development (CSS, JavaScript). I am fluent in python. I'm looking for a tool that is easy to use and doesn't require too much code knowledge. I have recently tried out Flask, but it is kinda complicated. Should I stick with it, move to Django, or is there another nice framework to use?
Golang
- High-performance552
- Simple, minimal syntax396
- Fun to write363
- Easy concurrency support via goroutines303
- Fast compilation times273
- Goroutines195
- Statically linked binaries that are simple to deploy181
- Simple compile build/run procedures151
- Great community137
- Backed by google137
- Garbage collection built-in53
- Built-in Testing47
- Excellent tools - gofmt, godoc etc44
- Elegant and concise like Python, fast like C40
- Awesome to Develop37
- Used for Docker26
- Flexible interface system26
- Great concurrency pattern25
- Deploy as executable24
- Open-source Integration21
- Easy to read19
- Fun to write and so many feature out of the box17
- Go is God17
- Powerful and simple14
- Easy to deploy14
- Its Simple and Heavy duty14
- Concurrency14
- Best language for concurrency13
- Safe GOTOs11
- Rich standard library11
- Clean code, high performance10
- Easy setup10
- High performance10
- Simplicity, Concurrency, Performance9
- Cross compiling8
- Single binary avoids library dependency issues8
- Hassle free deployment8
- Used by Giants of the industry7
- Simple, powerful, and great performance7
- Gofmt7
- Garbage Collection6
- WYSIWYG5
- Very sophisticated syntax5
- Excellent tooling5
- Keep it simple and stupid4
- Widely used4
- Kubernetes written on Go4
- No generics2
- Looks not fancy, but promoting pragmatic idioms1
- Operator goto1
- You waste time in plumbing code catching errors42
- Verbose25
- Packages and their path dependencies are braindead23
- Google's documentations aren't beginer friendly16
- Dependency management when working on multiple projects15
- Automatic garbage collection overheads10
- Uncommon syntax8
- Type system is lacking (no generics, etc)7
- Collection framework is lacking (list, set, map)5
- Best programming language3
- A failed experiment to combine c and python1
related Golang posts
How Uber developed the open source, end-to-end distributed tracing Jaeger , now a CNCF project:
Distributed tracing is quickly becoming a must-have component in the tools that organizations use to monitor their complex, microservice-based architectures. At Uber, our open source distributed tracing system Jaeger saw large-scale internal adoption throughout 2016, integrated into hundreds of microservices and now recording thousands of traces every second.
Here is the story of how we got here, from investigating off-the-shelf solutions like Zipkin, to why we switched from pull to push architecture, and how distributed tracing will continue to evolve:
https://eng.uber.com/distributed-tracing/
(GitHub Pages : https://www.jaegertracing.io/, GitHub: https://github.com/jaegertracing/jaeger)
Bindings/Operator: Python Java Node.js Go C++ Kubernetes JavaScript OpenShift C# Apache Spark
Winds 2.0 is an open source Podcast/RSS reader developed by Stream with a core goal to enable a wide range of developers to contribute.
We chose JavaScript because nearly every developer knows or can, at the very least, read JavaScript. With ES6 and Node.js v10.x.x, it’s become a very capable language. Async/Await is powerful and easy to use (Async/Await vs Promises). Babel allows us to experiment with next-generation JavaScript (features that are not in the official JavaScript spec yet). Yarn allows us to consistently install packages quickly (and is filled with tons of new tricks)
We’re using JavaScript for everything – both front and backend. Most of our team is experienced with Go and Python, so Node was not an obvious choice for this app.
Sure... there will be haters who refuse to acknowledge that there is anything remotely positive about JavaScript (there are even rants on Hacker News about Node.js); however, without writing completely in JavaScript, we would not have seen the results we did.
#FrameworksFullStack #Languages
NGINX
- High-performance http server1.4K
- Performance894
- Easy to configure730
- Open source607
- Load balancer530
- Free289
- Scalability288
- Web server226
- Simplicity175
- Easy setup136
- Content caching30
- Web Accelerator21
- Capability15
- Fast14
- High-latency12
- Predictability12
- Reverse Proxy8
- The best of them7
- Supports http/27
- Great Community5
- Lots of Modules5
- Enterprise version5
- High perfomance proxy server4
- Embedded Lua scripting3
- Streaming media delivery3
- Streaming media3
- Reversy Proxy3
- Blash2
- GRPC-Web2
- Lightweight2
- Fast and easy to set up2
- Slim2
- saltstack2
- Virtual hosting1
- Narrow focus. Easy to configure. Fast1
- Along with Redis Cache its the Most superior1
- Ingress controller1
- Advanced features require subscription10
related NGINX posts
Our whole DevOps stack consists of the following tools:
- GitHub (incl. GitHub Pages/Markdown for Documentation, GettingStarted and HowTo's) for collaborative review and code management tool
- Respectively Git as revision control system
- SourceTree as Git GUI
- Visual Studio Code as IDE
- CircleCI for continuous integration (automatize development process)
- Prettier / TSLint / ESLint as code linter
- SonarQube as quality gate
- Docker as container management (incl. Docker Compose for multi-container application management)
- VirtualBox for operating system simulation tests
- Kubernetes as cluster management for docker containers
- Heroku for deploying in test environments
- nginx as web server (preferably used as facade server in production environment)
- SSLMate (using OpenSSL) for certificate management
- Amazon EC2 (incl. Amazon S3) for deploying in stage (production-like) and production environments
- PostgreSQL as preferred database system
- Redis as preferred in-memory database/store (great for caching)
The main reason we have chosen Kubernetes over Docker Swarm is related to the following artifacts:
- Key features: Easy and flexible installation, Clear dashboard, Great scaling operations, Monitoring is an integral part, Great load balancing concepts, Monitors the condition and ensures compensation in the event of failure.
- Applications: An application can be deployed using a combination of pods, deployments, and services (or micro-services).
- Functionality: Kubernetes as a complex installation and setup process, but it not as limited as Docker Swarm.
- Monitoring: It supports multiple versions of logging and monitoring when the services are deployed within the cluster (Elasticsearch/Kibana (ELK), Heapster/Grafana, Sysdig cloud integration).
- Scalability: All-in-one framework for distributed systems.
- Other Benefits: Kubernetes is backed by the Cloud Native Computing Foundation (CNCF), huge community among container orchestration tools, it is an open source and modular tool that works with any OS.
We chose AWS because, at the time, it was really the only cloud provider to choose from.
We tend to use their basic building blocks (EC2, ELB, Amazon S3, Amazon RDS) rather than vendor specific components like databases and queuing. We deliberately decided to do this to ensure we could provide multi-cloud support or potentially move to another cloud provider if the offering was better for our customers.
We’ve utilized c3.large nodes for both the Node.js deployment and then for the .NET Core deployment. Both sit as backends behind an nginx instance and are managed using scaling groups in Amazon EC2 sitting behind a standard AWS Elastic Load Balancing (ELB).
While we’re satisfied with AWS, we do review our decision each year and have looked at Azure and Google Cloud offerings.
#CloudHosting #WebServers #CloudStorage #LoadBalancerReverseProxy
- Clean architecture554
- Growing community392
- Composer friendly370
- Open source344
- The only framework to consider for php325
- Mvc220
- Quickly develop210
- Dependency injection168
- Application architecture156
- Embraces good community packages143
- Write less, do more73
- Orm (eloquent)71
- Restful routing66
- Database migrations & seeds57
- Artisan scaffolding and migrations55
- Great documentation41
- Awesome40
- Awsome, Powerfull, Fast and Rapid30
- Build Apps faster, easier and better29
- Eloquent ORM28
- Promotes elegant coding26
- JSON friendly26
- Modern PHP26
- Most easy for me25
- Easy to learn, scalability24
- Beautiful23
- Blade Template22
- Test-Driven21
- Security15
- Based on SOLID15
- Cool13
- Clean Documentation13
- Easy to attach Middleware13
- Simple12
- Convention over Configuration12
- Easy Request Validatin11
- Simpler10
- Easy to use10
- Fast10
- Get going quickly straight out of the box. BYOKDM9
- Its just wow9
- Laravel + Cassandra = Killer Framework8
- Simplistic , easy and faster8
- Friendly API8
- Less dependencies7
- Super easy and powerful7
- Great customer support6
- Its beautiful to code in6
- Speed5
- Eloquent5
- Composer5
- Minimum system requirements5
- Laravel Mix5
- Easy5
- The only "cons" is wrong! No static method just Facades5
- Fast and Clarify framework5
- Active Record5
- Php75
- Ease of use4
- Laragon4
- Laravel casher4
- Easy views handling and great ORM4
- Laravel Forge and Envoy4
- Cashier with Braintree and Stripe4
- Laravel Passport3
- Laravel Spark3
- Intuitive usage3
- Laravel Horizon and Telescope3
- Laravel Nova3
- Rapid development3
- Laravel Vite2
- Scout2
- Deployment2
- Succint sintax1
- PHP54
- Too many dependency33
- Slower than the other two23
- A lot of static method calls for convenience17
- Too many include15
- Heavy13
- Bloated9
- Laravel8
- Confusing7
- Too underrated5
- Not fast with MongoDB4
- Slow and too much big1
- Not using SOLID principles1
- Difficult to learn1
related Laravel posts
I need to build a web application plus android and IOS apps for an enterprise, like an e-commerce portal. It will have intensive use of MySQL to display thousands (40-50k) of live product information in an interactive table (searchable, filterable), live delivery tracking. It has to be secure, as it will handle information on customers, sales, inventory. Here is the technology stack: Backend: Laravel 7 Frondend: Vue.js, React or AngularJS?
Need help deciding technology stack. Thanks.
Coming from a non-web development environment background, I was a bit lost a first and bewildered by all the varying tools and platforms, and spent much too long evaluating before eventualy deciding on Laravel as the main core of my development.
But as I started development with Laravel that lead me into discovering Vue.js for creating beautiful front-end components that were easy to configure and extend, so I decided to standardise on Vue.js for most of my front-end development.
During my search for additional Vue.js components, a chance comment in a @laravel forum , led me to discover Quasar Framework initially for it's wide range of in-built components ... but once, I realised that Quasar Framework allowed me to use the same codebase to create apps for SPA, PWA, iOS, Android, and Electron then I was hooked.
So, I'm now using mainly just Quasar Framework for all the front-end, with Laravel providing a backend API service to the Front-end apps.
I'm deploying this all to DigitalOcean droplets via service called Moss.sh which deploys my private GitHub repositories directly to DigitalOcean in realtime.
- Makes me Hapi making REST APIs27
- Simpler than other REST libraries14
- Configuration14
- Quality Driven Ecosystem13
- Modularization13
- Easy testability5
- Better validation1
- Restify0
related hapi posts
Heroku Docker GitHub Node.js hapi Vue.js AWS Lambda Amazon S3 PostgreSQL Knex.js Checkly is a fairly young company and we're still working hard to find the correct mix of product features, price and audience.
We are focussed on tech B2B, but I always wanted to serve solo developers too. So I decided to make a $7 plan.
Why $7? Simply put, it seems to be a sweet spot for tech companies: Heroku, Docker, Github, Appoptics (Librato) all offer $7 plans. They must have done a ton of research into this, so why not piggy back that and try it out.
Enough biz talk, onto tech. The challenges were:
- Slice of a portion of the functionality so a $7 plan is still profitable. We call this the "plan limits"
- Update API and back end services to handle and enforce plan limits.
- Update the UI to kindly state plan limits are in effect on some part of the UI.
- Update the pricing page to reflect all changes.
- Keep the actual processing backend, storage and API's as untouched as possible.
In essence, we went from strictly volume based pricing to value based pricing. Here come the technical steps & decisions we made to get there.
- We updated our PostgreSQL schema so plans now have an array of "features". These are string constants that represent feature toggles.
- The Vue.js frontend reads these from the vuex store on login.
- Based on these values, the UI has simple
v-ifstatements to either just show the feature or show a friendly "please upgrade" button. - The hapi API has a hook on each relevant API endpoint that checks whether a user's plan has the feature enabled, or not.
Side note: We offer 10 SMS messages per month on the developer plan. However, we were not actually counting how many people were sending. We had to update our alerting daemon (that runs on Heroku and triggers SMS messages via AWS SNS) to actually bump a counter.
What we build is basically feature-toggling based on plan features. It is very extensible for future additions. Our scheduling and storage backend that actually runs users' monitoring requests (AWS Lambda) and stores the results (S3 and Postgres) has no knowledge of all of this and remained unchanged.
Hope this helps anyone building out their SaaS and is in a similar situation.
JavaScript Node.js hapi Vue.js Swagger UI Slate
Two weeks ago we released the public API for Checkly. We already had an API that was serving our frontend Vue.js app. We decided to create an new set of API endpoints and not reuse the already existing one. The blog post linked below details what parts we needed to refactor, what parts we added and how we handled generating API documentation. More specifically, the post dives into:
- Refactoring the existing Hapi.js based API
- API key based authentication
- Refactoring models with Objection.js
- Validating plan limits
- Generating Swagger & Slate based documentation