#vue crud firebase

[skygola]

Full Stack Development: Bridging Frontend and Backend in Modern Web Applications

As technology evolves and businesses seek faster, more efficient ways to build digital products, full stack development has emerged as a critical skill in the tech industry. It combines both the frontend (what users see) and backend (what powers the system) to create complete, end-to-end web applications.

In this article, we’ll explore what full stack development is, its key technologies, benefits, career prospects, and how it powers the modern digital landscape.

What is Full Stack Development?

Full stack development refers to the process of developing both the client-side (frontend) and server-side (backend) of a web application. A full stack developer is someone proficient in both areas, capable of handling everything from designing user interfaces to managing databases and servers.

Key Areas of Full Stack Development:

Frontend (Client-Side)

Focuses on user experience and interface design.

Technologies: HTML, CSS, JavaScript, React, Angular, Vue.js

Backend (Server-Side)

Handles application logic, database operations, and server configuration.

Technologies: Node.js, Python, Java, PHP, Ruby; with frameworks like Express, Django, Spring Boot

Database Management

Stores, retrieves, and manages data for the application.

Technologies: MySQL, PostgreSQL, MongoDB, Firebase

Version Control & Deployment

Manages code collaboration and application deployment.

Tools: Git, GitHub, Docker, CI/CD, cloud platforms (AWS, Heroku, Vercel)

Popular Full Stack Tech Stacks

 MERN Stack

MongoDB, Express.js, React, Node.js

JavaScript-based stack ideal for dynamic web applications

 MEAN Stack

MongoDB, Express.js, Angular, Node.js

Great for enterprise-level apps

 LAMP Stack

Linux, Apache, MySQL, PHP

A traditional and powerful stack for dynamic websites

 Django + React

Python-based backend (Django) with React frontend

Secure and scalable

Why Full Stack Development Matters

 Versatility

Full stack developers can work on multiple layers of an application, making them highly adaptable and valuable in teams.

 Efficiency

They can understand and manage an entire project, reducing the need for extensive handovers between frontend and backend teams.

 Faster Prototyping

One person can take a project from idea to deployment, making it ideal for startups and MVP development.

 High Demand & Career Growth

Full stack developers are in high demand across tech industries, with diverse job opportunities and competitive salaries.

Skills Required for Full Stack Development

Frontend: HTML, CSS, JavaScript, responsive design, frameworks like React or Vue

Backend: API development, database integration, server-side logic

Database Management: CRUD operations, schema design

DevOps Basics: Deployment, testing, CI/CD, Git

Soft Skills: Problem-solving, collaboration, time management

Career Opportunities in Full Stack Development

Popular job roles include:

Full Stack Developer

Software Engineer

Web Developer

Technical Lead

Application Architect

Average Salary (US):Entry-Level: $65,000 – $85,000 Mid-Level: $90,000 – $120,000 Senior-Level: $120,000 – $150,000+

Challenges of Full Stack Development

Steep Learning Curve: Requires continuous learning in multiple technologies.

Time Management: Balancing both frontend and backend responsibilities can be challenging.

Rapid Tech Evolution: Frameworks and tools change frequently, requiring adaptability.

How to Start a Career in Full Stack Development

Master the Basics – Learn HTML, CSS, and JavaScript.

Pick a Stack – Choose MERN, LAMP, or another stack to specialize in.

Build Projects – Create real-world applications like blogs, e-commerce stores, or social platforms.

Use Git & GitHub – Practice version control and collaboration.

Learn Deployment – Use Heroku, Vercel, or AWS to host your applications.

Stay Updated – Follow tech blogs, take online courses, and engage with developer communities.

Conclusion

Full stack development is at the intersection of creativity and logic — allowing developers to build complete, functional, and scalable web applications. As the demand for all-in-one tech professionals continues to grow, becoming a full stack developer is both a valuable skill and a rewarding career path.

Whether you’re just starting out in tech or looking to level up your development skills, full stack development offers endless possibilities and a front-row seat to shaping the future of the web.

Location : https://g.co/kgs/H5YVuuF

[webcraft-notes]

Vue CRM Mastery: From Setup to Advanced Features

Embark on a comprehensive journey to build a robust CRM system using Vue.js! This 10-part tutorial series covers everything you need to know, including:

Project setup and structure

Implementing Vuetify for sleek UI

Firebase integration for authentication and data management

Creating dynamic layouts and secure navigation

Mastering data visualization with Vuetify tables

Enhancing user engagement with modals and alerts

Implementing CRUD operations

Perfect for developers looking to level up their Vue.js skills and add an impressive project to their portfolio. Follow along to create a fully-functional CRM from scratch!

Read the full tutorial series: https://webcraft-notes.com/blog/vue-crm-mastery-a-comprehensive-guide-to

[positronx]

This is a step by step tutorial that explains how to build a Vue js CRUD web application using Firebase database.

[laravelvuejs]

VueFire: CRUD Application with Vue.js and Firebase VueFire: CRUD Application with Vue.js and Firebase Want to learn how to integrate Firebase and Vuefire into your Vue.js applications? This video does just that ... source

[iamdeveloper]

How to Build a Vue.js CRUD Application with Firebase ☞ https://bit.ly/2xDObuh #Vue #Firebase #Morioh

[mobappdevelopmentcompany]

Significant React Native Libraries for Mobile App Development in 2021

React Native happens to be one of the most sought-after app development frameworks across the globe as it comes with a host of advantages like a cost-effective developmental cycle, faster time-to-market, high performance, modular and intuitive architecture, and many more.

One of the unique benefits of this framework is the availability of countless third-party libraries that expedite the development and prove highly convenient for every React Native App Development Company. However, owing to the presence of thousands of React Native libraries, selecting the apt ones becomes a herculean task. As a consequence, development teams often have to spare a great deal of time and effort for picking the right tool or library that would prove fruitful.

For easing out this task, I have penned down the most significant tools and libraries that complement the React Native framework. A quick read will help you to find the perfect match that suits your requirement.

Tools and Libraries for Various React Native App Development Categories

Category: User Interface

React Native Elements

This UI library, built using JavaScript, has earned 20.5k stars and 4.2k forks on GitHub.

This library comes with cross-platform compatibility and supports Expo.

It is easy to use, customizable, and community-driven.

Lottie-react-native

This library created by Airbnb enables adding attractive animations to React Native applications.

React Native developers can either select from the free animations available or design and add their animations employing “Adobe After Effects.”

Functioning: The animation data is exported in JSON format with Bodymovin and rendered natively on mobile.

Styled Components

This library enables developers to write CSS code for styling components

It removes the mapping between styles and components, thereby easing out the usage of components as a low-level styling construct.

The styles can be reused several times resulting in lesser coding

React Native Vector icons

React Native Vector icons is a library that offers numerous icons of various types, designed for the React Native Apps.

Each element can be fully customized

Category: Forms

Formik

It’s a small library that helps to build forms in React

Formik enables to validate the form values, display error messages and helps to submit the form.

Redux-form

Redux-form enables proper state management in Redux

It helps in tracking the commonest form states like fields contained in the form, focussed field, field values, fields which the users have interacted with, etc.

Category: Testing

Jest

This is a popular testing framework, designed and maintained by Facebook, and is used for testing JavaScript code. This versatile testing tool is compatible with any JavaScript framework or library, including React, Angular, VueJS, etc. Uber, Airbnb, and Intuit are some of the top brands that have leveraged this tool. Its offerings are:

High-speed performance

Standard syntax with report guide

Mocks functions, with the inclusion of third-party node_module libraries

Conducts parallelization, snapshot, and async method tests

Enables managing tests with bigger objects, by using live snapshots

Mocha

Mocha is a JavaScript test framework, used for testing React and React Native apps. It provides the Developers full control over what plugins and tools they choose to use while testing applications. Its major highlights are:

Runs on Node.js

Provides support for asynchronous front-end and backend testing, test coverage reports, and the usage of any claims library

Helps to track errors

Excels in mocking tests

Enzyme

Enzyme is another testing tool developed by Airbnb.

It comes with API wrappers, to ease out developers’ tasks like manipulating, asserting, and traversing the React DOM.

It supports full and shallow DOM and also supports static rendering

Besides, it is compatible with several other testing frameworks and libraries like Mocha and Jest.

Chai

It’s an assertion testing library meant for browser and node

Chai employs behavior-driven and test-driven development principles

Compatible with various testing tools and can be paired with any JS testing framework

Its functionality can be extended by using several custom plugins

Moreover, it enables the developers to create their plugins and share them in the community

Category: Navigation

React Navigation

This component supports navigational patterns like tabs, stacks, and drawers

It is based on JavaScript and is simple to use

It enables developers to effortlessly set up app screens

Can be completely customized as well as extended

React Router

This is a library of navigational components which composes declaratively with the app.

It allows one to specify named components, create various types of layouts, and pass layout components.

Category: App’s State Management

Redux

Redux, a free-standing library, and a predictable state container is predominantly used along with the UI library components of React. Besides the React ecosystem, one can also use Redux with other frameworks like Vue, Angular, Vanilla JS, Ember, etc. Its principal offerings are:

Can be used with back-end as well as front-end libraries

Enables the developers to write consistent codes

Allows editing the live code

Functions well in various environments – Server-side, client-side, and native

Connects the pieces of state to the React components by minimizing the need for props or callbacks.

Category: Linting and checking Types

ESLint

It’s a JavaScript-based, open-source linter tool

ESLint is configurable and pluggable

It improves the code consistency and makes it bug-free

It helps in evaluating patterns in the code and eliminates errors by automatically fixing the code, to enhance the overall code quality.

It helps detect creases in the JavaScript code that don’t comply with the standard guidelines

It helps react native developers to create their own linting rules

Flow

Developed by Facebook, Flow is a static type checker JavaScript library

It easily identifies problems during coding

It proves beneficial in crafting large applications, as it prevents bad rebases when several persons are working on a single program.

The main objective of Flow is to make the code more precise and enhance the speed of the coding process

Category: Networking

Networking tools are used to establish a networking flow in React Native projects. Let us have a look at a few of them.

react-native –firebase is a lightweight layer on the top of Firebase libraries. It creates a JavaScript bridge connecting to the native JavaScript SDKs to ease out using Firebase in React Native Application Development projects.

Apollo Client is quite compatible and adaptable. It is required when the developers need to use GraphQL. It assists in creating a User Interface that pulls data with GraphQL.

Axios, a lightweight HTTP JavaScript client was built to send asynchronous HTTP requests to REST endpoints. Besides, it performs CRUD operations.

react-native-ble-manager is a plugin that helps in connecting and transmitting data between a mobile handset and BLE peripherals.

Category: Utils

The below-mentioned ready-made tools simplify and speed up working with Utils while developing React Native apps.

Ramda is a library that eases out creating functional pipelines without user-data mutation.

The JavaScript functions’ toolkit Lodash offers clean and effective methodologies to your development team for working with collections and objects.

Reselect builds memorized selectors that are needed for avoiding unnecessary recalculation and redrawing of data. This library also quickens the speed of your app.

Moment works with various data formats and is capable of parsing, manipulating as well as validating times and dates in JavaScript.

Validate.js, designed by Wrap, offers the app developers a declarative way to validate JS objects

Category: Analytics

The following libraries act as mediators enabling one to implement the trending analytical tools into their React Native Mobile App Development projects.

react-native-mixpanel is a kind of wrapper for the library named Mixpanel and helps the developers to reap all the benefits of the Mixpanel library.

react-native-google-analytics-bridge acts as a bridge for establishing compatibility between Google Analytics tools and React Native projects.

Category: Localization

react-native-i18n helps in localizing or internationalizing applications. It integrates the i18n-js library in JavaScript for React Native applications.

Category: In-app Purchases

react-native-in-app-utils is a small library used to implement the in-app billing procedure for iOS apps. It can be effortlessly installed and is simple to work with.

react-native-billing is used for adding in-app billing to applications meant for the Android platform. It possesses a simple UI and wraps anjlab’s InApp Billing library to function as a bridge.

Category: AR and VR

ViroReact is used to speedily develop native cross-platform VR/AR apps in React Native. Its key functionalities are:

It has an easy learning curve

It comes with a high-performing native 3D rendering engine as well as a custom extension of React for creating VR and AR solutions.

It provides support for all kinds of platforms in VR including Samsung Gear VR, Google Cardboard, Google Daydream, etc. for Android and iOS; and AR including Android ARCore and iOS ARKit platforms.

Needs React-Viro-CLI and React-Native-CLI for writing cross-platform native codes

Final Verdict:

I hope the aforesaid information was helpful and has given you a clear idea of which library/libraries would be most suitable for your next project.

To know more about our other core technologies, refer to links below:

Angular App Development Company

Ionic App Development Company

Blockchain app developers

[offcampusjobs4u]

Create a CRUD Application with Ionic VueJS and Firebase

Create a CRUD Application with Ionic VueJS and Firebase

Create a CRUD Application with Ionic VueJS and Firebase Learn the basics Vue, Firebase and Ionic Framework and then build something amazing

[freeudemycourses]

[100% OFF] Vue.js: Learning the basics by building a movie web app What you Will learn ? Create Vue. application CRUD with Firebase and Firestore API service Vuex…

[mancdev]

VueJS & Firestore Stripped-Back - Tutorial Part 4

In this tutorial series we are stripping everything back to basics to explain how to build full-stack web applications with VueJS and Firebase Cloud Firestore - no CLIs, NPM or Webpack - just a html page and a code editor.

Updating your data

Welcome back. In this fourth part of our Stripped-Back tutorial we’re going to be explaining the U in CRUD - Updating data. By the way if you haven’t read the previous parts of this tutorial please feel free to do so using these links : Part 1, Part 2, Part 3

In the previous part of the tutorial we retrieved the data from our Firestore database by running a realtime query and populating an employees array with the data we retrieved including all of the fields such as lastName, jobTitle etc. However to be able to update (and indeed delete for that matter) we need to be able to get a handle on a unique ID for each employee document that is retrieved so we’ll know what to update when the user saves a change. If you remember from part 2, when you were checking your Firestore console, we mentioned a strange looking ID attached to each document in the Employees collection - this is what we’ll need to get hold of.

To do this we’ll first need to setup a place to store a unique id, so we’ll add an Id property to our employee object in the data section of our Vue Instance Object :

     var app = new Vue({          el : ’#app’,         data : {             appTitle : ‘EmployeeMagic’,             mainStyle : { ‘margin’ : ’20px’ },             employee : {firstName : ‘’,                                  lastName : ‘’,                                  jobTitle : ‘’,                                  dept : ‘’,                                  age : 0,                                  id : ‘’ },            db : {},            employees : [ ]         },

Next we’ll need to go back and change our callback function which gets the data from each document and puts it into our employees array. In there we’ll need to make sure the unique id from each document is stored in the employee’s new id property as well as the other fields.

    created : function() {         let that = this          that.db = firebase.firestore()                  let query = that.db.collection(’Employees’) .orderBy(’lastName’)          query.onSnapshot((snapshot) => {              that.employees = [ ]              snapshot.forEach((doc) => {                  that.employees.push({                           id : doc.id,                                          firstName  : doc.data().firstName,                      lastName : doc.data().lastName,                      jobTitle : doc.data().jobTitle,                      dept : doc.data().dept,                      age : doc.data().age                  })                          })          })     }

Notice we didn’t need to go through the data() method to get our id, it’s available directly on the document object itself. On our template, we’ll add an Edit button into the table alongside each employee so the end-user can click the Edit button next to the employee they want to update. We’ll add the button inside the Age column.

              <table class=“table table-bordered table-striped”>                                          <thead>                                                    <th>Name</th>                                                    <th>Job Title</th>                                                    <th>Department</th>                                                    <th>Age</th>                                            </thead> 

                   <tbody>                        <tr v-for=“employee in employees”>                                                  <td>{{ employee.firstName }} {{ employee.lastName }}</td>                            <td>{{ employee.jobTitle }}</td>                            <td>{{ employee.dept }}</td>                            <td>{{ employee.age }}                                    <button class="badge badge-primary">Edit</button>                             </td>                        </tr>                    </tbody>                                </table>

We obviously need to have a click event handler on the new Edit button but each button needs a reference to the employee it represents in order to know which one has been selected to be edited. Vue offers a way to deal with this by allowing a second parameter in the v-for directive. This second parameter can be used to expose the index of the array element that v-for is iterating over so we can reference it elsewhere, in this case we want to pass it as the parameter for our click event handler so the function we call knows the index of the employee it’s dealing with.

                       <tr v-for=“(employee, idx) in employees”>

We can now assign our click handler to our Edit button and pass in the index of each employee, using the idx that we exposed from v-for, as the parameter. We explained the v-on:click directive in part 2 (remember you can also use the shorthand @click if you’d like).

                                <button v-on:click=“editEmployee(idx)” class="badge badge-primary">Edit</button>

The next step is to implement the editEmployee() click handler which we can do by adding it to the methods object in our Vue Instance. Remember we’re implementing all of our methods in our Vue Instance as arrow functions.

      methods : {             saveEmployee : () => {                if ((app.employee.firstName) && (app.employee.lastName))                       app.db.collection(‘Employees’).add(app.employee)                    .then(function() {                         app.clearEmployee()                    })                   .catch(function() {                         console.log(‘Error saving employee ‘ + app.employee.firstName + ‘ ‘ + app.employee.lastName)                    })               else                     alert(‘You must enter both a first and last name to save.’)            },            editEmployee : (idx) => {                     },            clearEmployee : () => {               app.employee = { firstName : ‘’,                                              lastName : ‘’,                                              jobTitle : ‘’,                                              dept : ‘’,                                              age : 0 }            }       },

The job of the editEmployee function is to grab the selected employee’s information and populate the employee object’s properties from the correct element on the employees array. We can determine which employee in our array to use by referencing the idx parameter passed to the function from the button. Once our employee object is populated, Vue’s data binding takes care of the rest to display it on the page.

             editEmployee : (idx) => {                  let emp = app.employees[idx]                  if (emp) {                      app.employee = {                           id : emp.id,                           firstName : emp.firstName,                           lastName : emp.lastName,                           jobTitle : emp.jobTitle,                           dept : emp.dept,                           age : emp.age                                                  }                                      }                 },

Save the changes and refresh the browser and make sure everything is working as it should. You should see a blue Edit button in the Age column of the table and when you click it, that employee’s information should be displayed in the input boxes. We now need to handle saving updates to existing records when the user clicks Save rather than simply adding it as new record as it does now. We’ll keep the same Save button and the same saveEmployee click handler method, however we’ll make a decision as to whether we need to save as a new employee or as an update to an existing employee. The way to determine this is quite straightforward, if the employee object has a value in it’s id property it’s an existing record, otherwise it’s a new record. For this to work we need to make a quick change first to the clearEmployee method and ensure it clears the id property as well.

        clearEmployee : () => {               app.employee = { firstName : ‘’,                                            lastName : ‘’,                                            jobTitle : ‘’,                                            dept : ‘’,                                            age : 0,                                            id : ‘’ }            }

Let’s go to our saveEmployee method and add that condition to determine whether we’re saving a new employee or an existing one. For saving new employees we simply need to check if the employee.id isn’t set. Note that rather than simply save the employee object as we did previously, we’re defining a new object from the information in the employee object. The reason for this is simply that we’ve added an id property to the employee object and we don’t want to save this as an additional field on the document

         saveEmployee : () => {               if ((app.employee.firstName) && (app.employee.lastName)) {                   let saveEmp = {                                                firstName : employee.firstName,                                                lastName : employee.lastName,                                                jobTitle : employee.jobTitle,                                                dept : employee.dept,                                                age : employee.age                                             }                                                                       if (! app.employee.id)    //check if the id has not been set                                      app.db.collection(‘Employees’).add(saveEmp)                       .then(() => {                           app.clearEmployee()                       })                       .catch(() => {                         console.log(‘Error saving employee ‘ + app.employee.firstName + ‘ ‘ + app.employee.lastName)                       })                   else { }    //if the id has been set               }                            else                   alert(‘You must enter both a first and last name to save.’)           },

Now let’s see how to save an update to an existing employee. First of all we need to grab an object reference to the specific document we want to update and we get this using the id of the employee.

let docRef = app.db.collection('Employees').doc(app.employee.id)           

Now we’ve got a reference to the specific document in our Employees collection in Firestore, we can just simply call Firestore’s set() method and pass in the object with our updated information and our employee record will be updated.

 if (docRef)                                docRef.set(saveEmp)

The set() method is asynchronous, like most Firestore methods, so if there’s any code we want to execute once we’re certain that the update has saved, we can implement it in the returned promise’s then() method (as we covered in part 2). In the method we pass to then() we simply call clearEmployee to clear the inputs and make it ready to add a new employee again, just as we did when adding new employees (and we’ll add a catch() just in case).

    if (docRef)         docRef.set(saveEmp)         .then(() => {             app.clearEmployee()                })         .catch(() => {             console.log(’Update to ‘ + app.firstName + ' ' + app.lastName + ' did not save!');                })

So let’s put this all together in our saveEmployee method :

        saveEmployee : () => {              if ((app.employee.firstName) && (app.employee.lastName)) {                  let saveEmp = {                                               firstName : app.employee.firstName,                                               lastName : app.employee.lastName,                                               jobTitle : app.employee.jobTitle,                                               dept : app.employee.dept,                                               age : app.employee.age                                            }                                                                      if (! app.employee.id)    //check if the id has not been set                                     app.db.collection(‘Employees’).add(saveEmp)                       .then(() => {                           app.clearEmployee()                       })                       .catch(() => {                         console.log(‘Error saving employee ‘ + app.employee.firstName + ‘ ‘ + app.employee.lastName)                       })                  else {     //if the id has been set, we save an update                      let docRef = app.db.collection('Employees').doc(app.employee.id)                       if (docRef)                          docRef.set(saveEmp)                          .then(() => {                              app.clearEmployee()                                  })                         .catch(() => {                             console.log(’Error updating employee ‘ + app.firstName + ' ' + app.lastName)                                })                  }                 }                            else                   alert(‘You must enter both a first and last name to save.’)           },

This is fairly verbose and we could certainly tidy things up but it works and it’s verbosity helps to explain what it is we’re doing so we’ll leave this as it is. Before we close this part of the tutorial off and let you go and get a much deserved coffee, let’s add one more little piece of functionality to our app. Things are great, but let’s say the user clicks to Edit an employee and realises they don’t want to save - at the moment there’s no way for them to go back to add a new one. To get around this we’ll put an Add button next to the Save button that let’s them click to add a new employee. This button however should only be available if they’re editing an existing employee.

           <label>Age</label>            <input type=“number” v-model:number=“employee.age”></br>                      <button v-on:click=“saveEmployee()”>Save</button>             <button v-on:click=“clearEmployee()”>Add</button>             </div>

Notice we’re directly calling our clearEmployee method as our event handler as that does everything we need to put our app into Add mode. Cool, but remember we only want to show this button if the user is in Edit mode. The way to do this is to use Vue’s conditional directive, v-if. This lets us include a conditional statement on the element, whether directly of via a method call, to determine if it should be visible on the page. In this case we want to check if the current employee object has an id set, if it has then we’re in edit mode so show the Add button, otherwise don’t show it.

            <button v-if=“employee.id” v-on:click=“clearEmployee()”>Add</button>

That’ll do for this part of the tutorial dedicated to the U in CRUD. In this part we’ve covered retrieving each document’s unique id along with the other fields. We’ve added an Edit button for each employee in the list and exposed an index from our v-for directive to assign an employee index from our array so each button knows which employee it relates to. We‘ve saved our employee updates back to the database using the unique id of each document and finally we covered using v-if to conditionally show a button on our page. In the next part of this tutorial we’ll cover the D in CRUD - deleting. Hope you can join me.

You can download the completed code for this part of the tutorial on Github using the repo below and select the part4 folder. https://github.com/MancDev/VueFire

[javascript4u]

How to Build a Vue.js CRUD Application with Firebase ☞ https://bit.ly/2xDObuh #Vue #Firebase #Morioh

[javascriptonline]

How to Build a Vue.js CRUD Application with Firebase ☞ https://bit.ly/2xDObuh #Vue #Firebase #Morioh

[javascriptnews4u]

How to Build a Vue.js CRUD Application with Firebase ☞ https://bit.ly/2xDObuh #Vue #Firebase #Morioh

[laravelvuejs]

✔ CRUD LocalStorage con Vue.js [Tutorial en Español] Framework Javascript ❤

✔ CRUD LocalStorage con Vue.js [Tutorial en Español] Framework Javascript ❤

Curso VUE.JS + FIREBASE [Udemy] aquí: http://curso-vue-js-udemy.bluuweb.cl Hoy revisaremos como realizar un CRUD de tareas en Vue.js y LocalStorage, así nuestros datos serán persistentes en el navegador del cliente. Descubre la magia de este poderoso framework de Javascript. Curso en Udemy de Vue.js: http://curso-vue-js-udemy.bluuweb.cl ✔ Video anterior con Vanilla Javascript:…

[vuejstutorialblog]

How to Build a Vue.js CRUD Application with Firebase ☞ https://bit.ly/2xDObuh #Vue #Firebase #Morioh

[javascriptdevz]

How to Build a Vue.js CRUD Application with Firebase ☞ https://bit.ly/2xDObuh #Vue #Firebase #Morioh

[vuezone]

How to Build a Vue.js CRUD Application with Firebase ☞ https://bit.ly/2xDObuh #Vue #Firebase #Morioh