Forem: Asutosh Padhi

🚀 Updating and Deleting Tasks in Our .NET + PostgreSQL Todo API

Asutosh Padhi — Wed, 01 Oct 2025 16:35:54 +0000

In the previous post, we created new tasks and got our backend to communicate with PostgreSQL. By including Update (PUT) and Delete (DELETE) routes, we will finish the circle today. This indicates that our small API can now perform full CRUD!

But first, a brief note before we get into the code:
👉 It wasn't the best idea to store PostgreSQL credentials directly in appsettings.json, as someone noted in the previous post's comments. It's true! An environment variable (or a .env file with something like dotnet user-secrets or dotenv.net) can be used instead. In this manner, you can avoid inadvertently entering your database password into GitHub.

🔧 Step 1: Adding Update (PUT) Route

When we update, we take an existing task, make changes to its fields, and then save it again. That is typically a FindAsync → modify → SaveChangesAsync pattern in EF Core.

This is how it appears in a minimalist API style:

// Update a task
app.MapPut("/api/tasks/{id}", async (AppDbContext db, int id, TodoItem updatedTask) =>
{
    var toBeUpdated = await db.Tasks.FindAsync(id);
    if (toBeUpdated == null) return Results.NotFound();

    toBeUpdated.Title = updatedTask.Title;
    toBeUpdated.IsComplete = updatedTask.IsComplete;

    await db.SaveChangesAsync();
    return Results.Ok(toBeUpdated);
});

🔍 What is going on here?

The URL (/api/tasks/3) is where the id originates.
db is the database context that .NET injects into our database.
The request body (the updated values) is where updatedTask originates.
We update the task's fields, verify that it exists, and then save.

🔧 Step 2: Adding the delete (DELETE) route

Deleting is even simpler:

// Delete a task
app.MapDelete("/api/tasks/{id}", async (int id, AppDbContext db) =>
{
    var task = await db.Tasks.FindAsync(id);
    if (task == null) return Results.NotFound();

    db.Tasks.Remove(task);
    await db.SaveChangesAsync();

    return Results.Ok(new { message = $"Task {id} deleted" });
});

That’s it! If the task is found, it’s removed. Otherwise, the API returns a 404 Not Found.

🔧Step 3: Trying it our on Postman

PUT: Send a request to http://localhost:5001/api/tasks/1 with body:

{
  "title": "Write blog post",
  "isComplete": true
}

DELETE: Send a request to http://localhost:5001/api/tasks/1.

That's it! If you've done everything as suggested, the routes will update the task with ID 1 and delete it respectively.

🌱 Small Improvement: Store DB Credentials in Environment Variables

Instead of in appsettings.json:

"ConnectionStrings": {
  "DefaultConnection": "Host=localhost;Database=todo_db;Username=postgres;Password=supersecret"
}

Use environment variables through Program.cs (cross-platform safe):

builder.Services.AddDbContext<AppDbContext>(options => options.UseNpgsql(Environment.GetEnvironmentVariable("PG_CONNECTION")));

And in your shell:

export PG_CONNECTION="Host=localhost;Database=todo_db;Username=postgres;Password=supersecret"

This way, you won’t leak secrets into GitHub.

🗂️ Full Codebase + Frontend

I've posted the complete codebase to GitHub, go there if you want to view it, tweak it and build it along with the React frontend that uses this API.

That way, you won't just be reading snippets.

🐘 Building a To-do API in .NET with PostgreSQL (Beginner Friendly)

Asutosh Padhi — Tue, 30 Sep 2025 18:18:49 +0000

So I’ve been picking up .NET lately, and one of the first real things I wanted to do was connect it to a database. An API with a frontend is nice, but let’s be honest — the fun starts when we can store stuff.

In this post, I’ll walk you through how I connected a minimal .NET API to PostgreSQL using Entity Framework Core (EF Core). Don’t worry, I’ll explain the new C#/.NET bits as we go along (coming from a JS/Node background myself, I needed that).

By the end, you’ll have:

A tiny Todo API in .NET
A PostgreSQL database behind it
The ability to add and fetch tasks

🎒 What you’ll need

.NET SDK installed
PostgreSQL installed and running locally
A blank database created (I called mine todo_db)
Postman (or curl) to test things

1. Install a couple of packages

From your backend folder:

dotnet add package Npgsql.EntityFrameworkCore.PostgreSQL
dotnet add package Microsoft.EntityFrameworkCore.Design

👉 Translation:

The first one is the PostgreSQL driver for EF Core.
The second one is the “design-time tools” EF needs to run migrations.

2. Add a connection string

Inside appsettings.json:

{
  "ConnectionStrings": {
    "DefaultConnection": "Host=localhost;Database=todo_db;Username=postgres;Password=yourpassword"
  }
}

This is basically your database “address book entry.”

3. Create a Todo model

Models/Todo.cs:

namespace backend.Models;

public class Todo
{
    public int Id { get; set; }          // primary key
    public string Title { get; set; } = string.Empty;
    public bool IsComplete { get; set; }
}

Think of it like a schema in Mongo or a table in SQL. EF Core will map this to a database table.

4. Add a DbContext

Data/AppDbContext.cs:

using backend.Models;
using Microsoft.EntityFrameworkCore;

namespace backend.Data;

public class AppDbContext : DbContext
{
    public AppDbContext(DbContextOptions<AppDbContext> options) : base(options) { }

    public DbSet<Todo> Tasks { get; set; } = null!;
}

This is EF Core’s way of saying: “Hey, here’s how I should talk to the database.”

5. Wire it up in `Program.cs`

using backend.Data;
using backend.Models;
using Microsoft.EntityFrameworkCore;

var builder = WebApplication.CreateBuilder(args);

// hook up PostgreSQL
builder.Services.AddDbContext<AppDbContext>(options =>
    options.UseNpgsql(builder.Configuration.GetConnectionString("DefaultConnection")));

var app = builder.Build();

// GET all tasks
app.MapGet("/api/tasks", async (AppDbContext db) =>
    await db.Tasks.ToListAsync());

// POST a new task
app.MapPost("/api/tasks", async (AppDbContext db, Todo task) =>
{
    db.Tasks.Add(task);
    await db.SaveChangesAsync();
    return Results.Created($"/api/tasks/{task.Id}", task);
});

app.Run();

Notice how AppDbContext is just injected into the endpoint — no new-ing up objects yourself. .NET handles that for you.

6. Run migrations

This creates the actual database table:

dotnet ef migrations add InitialCreate
dotnet ef database update

After this, PostgreSQL has a Tasks table ready for action.

7. Test it with Postman

POST → http://localhost:5000/api/tasks

{
  "title": "Learn EF Core",
  "isComplete": false
}

GET → http://localhost:5000/api/tasks

And you’ll see your shiny new tasks, straight from PostgreSQL.

✅ Wrap up

And that’s it — we’ve got a .NET minimal API talking to PostgreSQL with EF Core in the middle doing all the heavy lifting.

Next up I’ll explore adding update and delete routes, so we’ll have the full CRUD cycle working.

Spinning Up a Minimal To-do List API in .NET

Asutosh Padhi — Tue, 30 Sep 2025 12:39:48 +0000

As a JavaScript developer, I’ve always worked with React + NodeJS, but I recently decided to dive into .NET to understand how to build a strong backend. In this post, I’ll walk through creating a minimal To-do List API using ASP.NET Core, and how to connect it to a React frontend.
This tutorial is beginner-friendly and assumes you know React but are new to C# and .NET.

Step 1: Setting Up the Project

First, make sure you have the .NET SDK installed. You can check:

dotnet --version

Then, create a new project:

dotnet new web -o TodoListBackend
cd TodoListBackend

web → minimal API template.
TodoListBackend → project folder.

Step 2: Understanding the Project Structure

Program.cs → the main entry point for your backend. All routes and configuration live here in a minimal API.
launchSettings.json → defines which ports the server runs on.

By default, .NET listens on:

HTTP → http://localhost:5000
HTTPS → https://localhost:5001

But you can check or change your PORT numbers by navigating to TodoListBackend → Properties → launchSettings.json

For local development, it’s easiest to stick to HTTP to avoid SSL headaches.

Step 3: Adding a Minimal Todo Endpoint

Open Program.cs and replace the content with the following:

var builder = WebApplication.CreateBuilder(args);

// Enable CORS so React can talk to this API
builder.Services.AddCors(options =>
{
    options.AddDefaultPolicy(policy =>
    {
        policy.WithOrigins("http://localhost:3000") // React dev server
              .AllowAnyHeader()
              .AllowAnyMethod();
    });
});

var app = builder.Build();

// Apply CORS middleware
app.UseCors();

// Simple "ping" endpoint to confirm server is running
app.MapGet("/", () => "Server is running!");

// Minimal Todo List endpoint
app.MapGet("/api/tasks", () => new[] { "Clean", "Cook", "Study", "Get a job" });

// Start the server
app.Run();

Key Points:

MapGet → defines a GET endpoint.
CORS must be applied before routes so the browser can make requests.
Returning an array in C# automatically gets converted to JSON.

Step 4: Running the Backend

dotnet run

You should see something like:

Now listening on: http://localhost:5000
Application started. Press Ctrl+C to shut down.

Test it in your browser:

http://localhost:5000/
http://localhost:5000/api/tasks

You should see:

["Clean","Cook","Study","Get a job"]

Step 5: Connect React to Your API

In your React app:

import { useEffect, useState } from "react";

function App() {
  const [tasks, setTasks] = useState([]);

  useEffect(() => {
    fetch("http://localhost:5000/api/tasks")
      .then(res => res.json())
      .then(data => setTasks(data))
      .catch(err => console.error(err));
  }, []);

  return (
    <div>
      <h1>My Todo List</h1>
      <ul>
        {tasks.map((task, i) => <li key={i}>{task}</li>)}
      </ul>
    </div>
  );
}

export default App;

Make sure the fetch URL matches your backend port.
React doesn’t care whether the backend is Node or .NET — it just fetches JSON.

Step 6: Optional Enhancements

1. Hot Reload for Backend

dotnet watch run

Detects changes in C# files and reloads automatically (like nodemon in Node).

2. Logging server start

var logger = app.Services.GetRequiredService<ILogger<Program>>();
logger.LogInformation("🚀 Server is up at http://localhost:5000");

3. Returning structured JSON

app.MapGet("/api/tasks", () => new { tasks = new[] { "Clean", "Cook" } });

Makes the API more standard and easier to consume.

Step 7: Tips for Writing Your First .NET API

Strong typing matters: C# enforces variable types — fewer runtime errors.
Middleware order matters: CORS → Logging → Routes.
Test your API in Postman or browser first before connecting React.

✅ Conclusion

Congratulations! You now have a minimal Todo List API in .NET running locally and feeding a React frontend.

Next steps:

Connect a MySQL or SQL Server database.
Implement POST, PUT, DELETE endpoints for full CRUD.
Add authentication or more complex business logic.