Develop a full-stack web application using React for the frontend and Node.js/Express for the backend. The application should allow users to create, read, update, and delete notes. Store the notes in a MongoDB database and use authentication via JWT tokens to secure the API endpoints.
To develop a full-stack web application using React for the frontend and Node.js/Express for the backend, follow these steps:

1. Set up the project structure

Create a new folder for your project and navigate to it in the terminal. Then, create two folders inside: one called "frontend" and another called "backend".

```
mkdir notes-app
cd notes-app
mkdir frontend backend
```

2. Set up the backend

Navigate to the "backend" folder and initialize a new Node.js project.

```
cd backend
npm init -y
```

Install the necessary dependencies:

```
npm install express mongoose cors dotenv jsonwebtoken bcryptjs
```

Create an "index.js" file that will serve as the entry point for your backend server.

```
touch index.js
```

Inside "index.js", set up a basic Express server and connect to MongoDB using Mongoose:

```javascript
const express = require('express');
const mongoose = require('mongoose');
const cors = require('cors');
require('dotenv').config();

const app = express();
app.use(express.json());
app.use(cors());

mongoose.connect(process.env.MONGODB_URI, {
  useNewUrlParser: true,
  useUnifiedTopology: true,
});

const db = mongoose.connection;
db.on('error', console.error.bind(console, 'connection error:'));
db.once('open', () => {
  console.log('Connected to MongoDB');
});

app.listen(5000, () => {
  console.log('Server running on port 5000');
});
```

3. Create the Note model and API routes

In the "backend" folder, create a new folder called "models" and inside it, create a file named "Note.js". Define the schema for the Note model:

```javascript
const mongoose = require('mongoose');

const noteSchema = new mongoose.Schema({
  title: { type: String, required: true },
  content: { type: String, required: true },
  user: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
});

module.exports = mongoose.model('Note', noteSchema);
```

Create a new folder called "routes" and inside it, create a file named "notes.js". Define the API routes for creating, reading, updating, and deleting notes:

```javascript
const express = require('express');
const router = express.Router();
const Note = require('../models/Note');

// Add authentication middleware here

router.get('/', async (req, res) => {
  try {
    const notes = await Note.find({ user: req.user.id });
    res.json(notes);
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});

router.post('/', async (req, res) => {
  const note = new Note({
    title: req.body.title,
    content: req.body.content,
    user: req.user.id,
  });

  try {
    const newNote = await note.save();
    res.status(201).json(newNote);
  } catch (err) {
    res.status(400).json({ message: err.message });
  }
});

router.patch('/:id', getNote, async (req, res) => {
  if (req.body.title != null) {
    res.note.title = req.body.title;
  }

  if (req.body.content != null) {
    res.note.content = req.body.content;
  }

  try {
    const updatedNote = await res.note.save();
    res.json(updatedNote);
  } catch (err) {
    res.status(400).json({ message: err.message });
  }
});

router.delete('/:id', getNote, async (req, res) => {
  try {
    await res.note.remove();
    res.json({ message: 'Note deleted' });
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});

async function getNote(req, res, next) {
  let note;
  try {
    note = await Note.findById(req.params.id);
    if (note == null) {
      return res.status(404).json({ message: 'Cannot find note' });
    }
  } catch (err) {
    return res.status(500).json({ message: err.message });
  }

  res.note = note;
  next();
}

module.exports = router;
```

4. Set up authentication

Create a new folder called "auth" and inside it, create a file named "middleware.js". Implement the JWT authentication middleware:

```javascript
const jwt = require('jsonwebtoken');

function auth(req, res, next) {
  const token = req.header('x-auth-token');
  if (!token) return res.status(401).send('Access denied. No token provided.');

  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    req.user = decoded;
    next();
  } catch (ex) {
    res.status(400).send('Invalid token.');
  }
}

module.exports = auth;
```

5. Set up the frontend

Navigate to the "frontend" folder and create a new React app using Create React App:

```
cd ../frontend
npx create-react-app .
```

Install necessary dependencies:

```
npm install axios react-router-dom
```

6. Build the frontend components

Create components for displaying notes, creating notes, updating notes, and deleting notes. Use Axios to make API calls to your backend server.

7. Deploy the application

Deploy the frontend to a hosting service like Netlify or Vercel, and deploy the backend to a platform like Heroku. Make sure to set up environment variables for your MongoDB connection string and JWT secret.