Sure thing! Here's a full-stack CRUD example—NestJS backend and React frontend using Axios—built around your original Express + Mongoose server.js setup. I’ve also included tips from real tutorials to make it smooth. Feel free to customize the data model to suit your needs (users, tasks, products, etc.).

Backend: NestJS with Mongoose
1. Initialize and Set Up NestJS Project
npm i -g @nestjs/cli
nest new nest-backend
cd nest-backend
npm install @nestjs/mongoose mongoose


In src/main.ts, enable CORS:

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.enableCors();
  await app.listen(3000);
}
bootstrap();


Restack

2. Connect to MongoDB

In src/app.module.ts:

import { Module } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';
import { ItemModule } from './item/item.module';

@Module({
  imports: [
    MongooseModule.forRoot('mongodb://localhost:27017/mydb'),
    ItemModule,
  ],
})
export class AppModule {}

3. Create Item Module, Schema, Service & Controller

Run: nest generate module item, nest generate service item, nest generate controller item.

item.schema.ts:
import { Schema, Document } from 'mongoose';
export type ItemDocument = Item & Document;

export class Item {
  name: string;
  description: string;
  createdAt: Date;
}

export const ItemSchema = new Schema<Item>({
  name: { type: String, required: true },
  description: String,
  createdAt: { type: Date, default: Date.now },
});

item.module.ts:
import { Module } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';
import { Item, ItemSchema } from './item.schema';
import { ItemService } from './item.service';
import { ItemController } from './item.controller';

@Module({
  imports: [
    MongooseModule.forFeature([{ name: Item.name, schema: ItemSchema }]),
  ],
  providers: [ItemService],
  controllers: [ItemController],
})
export class ItemModule {}

item.service.ts:
import { Injectable, NotFoundException } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Model } from 'mongoose';
import { Item, ItemDocument } from './item.schema';

@Injectable()
export class ItemService {
  constructor(@InjectModel(Item.name) private itemModel: Model<ItemDocument>) {}

  async create(data: Partial<Item>): Promise<Item> {
    const created = new this.itemModel(data);
    return created.save();
  }

  async findAll(): Promise<Item[]> {
    return this.itemModel.find().exec();
  }

  async findOne(id: string): Promise<Item> {
    const item = await this.itemModel.findById(id).exec();
    if (!item) throw new NotFoundException('Item not found');
    return item;
  }

  async update(id: string, data: Partial<Item>): Promise<Item> {
    const updated = await this.itemModel.findByIdAndUpdate(id, data, { new: true }).exec();
    if (!updated) throw new NotFoundException('Item not found');
    return updated;
  }

  async remove(id: string): Promise<void> {
    const result = await this.itemModel.findByIdAndDelete(id).exec();
    if (!result) throw new NotFoundException('Item not found');
  }
}

item.controller.ts:
import { Controller, Get, Post, Body, Param, Put, Delete } from '@nestjs/common';
import { ItemService } from './item.service';
import { Item } from './item.schema';

@Controller('items')
export class ItemController {
  constructor(private readonly itemService: ItemService) {}

  @Post() create(@Body() dto: Partial<Item>) {
    return this.itemService.create(dto);
  }

  @Get() findAll() {
    return this.itemService.findAll();
  }

  @Get(':id') findOne(@Param('id') id: string) {
    return this.itemService.findOne(id);
  }

  @Put(':id') update(@Param('id') id: string, @Body() dto: Partial<Item>) {
    return this.itemService.update(id, dto);
  }

  @Delete(':id') remove(@Param('id') id: string) {
    return this.itemService.remove(id);
  }
}


This gives you a working CRUD RESTful API using NestJS and Mongoose. You can refer to similar patterns at Restackio for NestJS + Mongoose CRUD examples 
Restack
.

Frontend: React + Axios
1. Create React App + Axios
npx create-react-app frontend
cd frontend
npm install axios

2. API Service (src/services/itemService.js):
import axios from 'axios';
const API = 'http://localhost:3000/items';

export const getItems = () => axios.get(API).then(res => res.data);
export const createItem = (item) => axios.post(API, item).then(res => res.data);
export const getItem = (id) => axios.get(`${API}/${id}`).then(res => res.data);
export const updateItem = (id, item) => axios.put(`${API}/${id}`, item).then(res => res.data);
export const deleteItem = (id) => axios.delete(`${API}/${id}`);

3. Components
ItemForm.jsx — for create/update:
import React, { useState, useEffect } from 'react';
import { createItem, updateItem, getItem } from '../services/itemService';

const ItemForm = ({ id, onSuccess }) => {
  const [name, setName] = useState('');
  const [description, setDescription] = useState('');

  useEffect(() => {
    if (id) {
      getItem(id).then(data => {
        setName(data.name);
        setDescription(data.description || '');
      });
    }
  }, [id]);

  const handleSubmit = async (e) => {
    e.preventDefault();
    if (id) await updateItem(id, { name, description });
    else await createItem({ name, description });
    onSuccess();
    setName('');
    setDescription('');
  };

  return (
    <form onSubmit={handleSubmit}>
      <input value={name} onChange={e => setName(e.target.value)} placeholder="Name" required />
      <textarea value={description} onChange={e => setDescription(e.target.value)} placeholder="Description" />
      <button type="submit">{id ? 'Update' : 'Create'}</button>
    </form>
  );
};
export default ItemForm;

ItemList.jsx — list and delete:
import React, { useState, useEffect } from 'react';
import { getItems, deleteItem } from '../services/itemService';

const ItemList = ({ onEdit }) => {
  const [items, setItems] = useState([]);

  const load = () => getItems().then(data => setItems(data));
  useEffect(() => load(), []);

  const handleDelete = async (id) => {
    await deleteItem(id);
    load();
  };

  return (
    <ul>
      {items.map(item => (
        <li key={item._id}>
          <strong>{item.name}</strong>: {item.description}
          <button onClick={() => onEdit(item._id)}>Edit</button>
          <button onClick={() => handleDelete(item._id)}>Delete</button>
        </li>
      ))}
    </ul>
  );
};
export default ItemList;

4. App.jsx: Combine both
import React, { useState } from 'react';
import ItemForm from './components/ItemForm';
import ItemList from './components/ItemList';

const App = () => {
  const [editingId, setEditingId] = useState(null);

  const onSuccess = () => setEditingId(null);

  return (
    <div>
      <h1>Item CRUD</h1>
      <ItemForm id={editingId} onSuccess={onSuccess} />
      <ItemList onEdit={setEditingId} />
    </div>
  );
};

export default App;

Summary
Part	Description
Backend	NestJS with Mongoose: full CRUD REST API
Frontend	React + Axios: create, list, update, delete UI
Tutorial Insights	Mirrors patterns from Restackio and Medium on integrating NestJS + React