Quick Start Guide: Database .NET Free Options and Setups

How to Build a Database .NET App Using Free ToolsBuilding a database-backed .NET application using free tools is both practical and economical. This guide walks you through selecting tools, designing the schema, setting up the environment, implementing data access and business logic, testing, and deploying—all using free software and services. Examples use .NET 8 (or later) and C#, but the concepts apply across .NET Core and .NET Framework where relevant.

Why choose free tools?

Free tools reduce upfront costs, increase accessibility for hobbyists and startups, and often include active communities and extensive documentation. You can build production-ready applications with zero license fees by combining the right open-source or freemium tools.

Key free components you’ll use

.NET SDK (Microsoft .NET, free)
Visual Studio Code (free editor) or Visual Studio Community (free IDE)
Database engines: PostgreSQL, MySQL/MariaDB, or SQLite (all free)
Entity Framework Core or Dapper (free ORMs)
Git and GitHub/GitLab (free code hosting and version control)
Docker (free Community edition for local containers)
Postman or curl (free API testing)
CI/CD: GitHub Actions or GitLab CI (free tiers)

1. Plan the application

Start with purpose and requirements. Decide:

App type: web API, web app (MVC/Blazor), desktop, or CLI.
Scale: expected users and data size.
Data needs: entities, relationships, and queries.
Nonfunctional requirements: performance, security, backups.

Example app for this guide: a simple task manager with users, projects, and tasks.

2. Choose your tech stack

A recommended free stack:

.NET 8+ (runtime & SDK)
ASP.NET Core Web API (for backend)
Entity Framework Core (ORM)
PostgreSQL (database)
Visual Studio Code + C# extensions
Docker for containerized local DB
Git + GitHub for source control
GitHub Actions for CI

PostgreSQL is a strong free choice (robust, SQL-compliant, good tooling). SQLite is ideal for prototypes or desktop apps. MySQL/MariaDB are fine alternatives.

3. Set up the development environment

Install .NET SDK from Microsoft (.NET 8 or latest LTS).
Install Visual Studio Code and the C# extension (OmniSharp).
Install Git and create a GitHub repository.
Install Docker Desktop (optional but recommended).
Install PostgreSQL locally or run it with Docker:

Docker command:

docker run --name pg-demo -e POSTGRES_PASSWORD=pass -e POSTGRES_USER=appuser -e POSTGRES_DB=taskdb -p 5432:5432 -d postgres:15

4. Create the project

From a terminal:

dotnet new webapi -n TaskManager cd TaskManager dotnet add package Npgsql.EntityFrameworkCore.PostgreSQL dotnet add package Microsoft.EntityFrameworkCore.Design

This creates an ASP.NET Core Web API project and adds EF Core with the PostgreSQL provider.

5. Design the database model

Define entities with relationships. Example C# models:

public class User {     public int Id { get; set; }     public string Username { get; set; } = null!;     public ICollection<Project> Projects { get; set; } = new List<Project>(); } public class Project {     public int Id { get; set; }     public string Name { get; set; } = null!;     public int UserId { get; set; }     public User User { get; set; } = null!;     public ICollection<TaskItem> Tasks { get; set; } = new List<TaskItem>(); } public class TaskItem {     public int Id { get; set; }     public string Title { get; set; } = null!;     public bool IsCompleted { get; set; }     public DateTime? DueDate { get; set; }     public int ProjectId { get; set; }     public Project Project { get; set; } = null!; }

Create a DbContext:

public class AppDbContext : DbContext {     public AppDbContext(DbContextOptions<AppDbContext> options) : base(options) { }     public DbSet<User> Users => Set<User>();     public DbSet<Project> Projects => Set<Project>();     public DbSet<TaskItem> Tasks => Set<TaskItem>();     protected override void OnModelCreating(ModelBuilder modelBuilder)     {         modelBuilder.Entity<User>().HasIndex(u => u.Username).IsUnique();     } }

6. Configure database connection

In appsettings.Development.json:

{   "ConnectionStrings": {     "DefaultConnection": "Host=localhost;Port=5432;Database=taskdb;Username=appuser;Password=pass"   } }

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

Apply EF Core tools:

dotnet tool install --global dotnet-ef dotnet ef migrations add InitialCreate dotnet ef database update

If using Dockerized DB, ensure the container is running before running migrations.

7. Implement data access

You can use EF Core repositories or query directly with DbContext. For clarity, example of a simple repository:

public interface ITaskRepository {     Task<IEnumerable<TaskItem>> GetAllAsync(int projectId);     Task<TaskItem?> GetByIdAsync(int id);     Task AddAsync(TaskItem task);     Task SaveChangesAsync(); } public class TaskRepository : ITaskRepository {     private readonly AppDbContext _db;     public TaskRepository(AppDbContext db) => _db = db;     public async Task<IEnumerable<TaskItem>> GetAllAsync(int projectId) =>         await _db.Tasks.Where(t => t.ProjectId == projectId).ToListAsync();     public async Task<TaskItem?> GetByIdAsync(int id) => await _db.Tasks.FindAsync(id);     public async Task AddAsync(TaskItem task) => await _db.Tasks.AddAsync(task);     public async Task SaveChangesAsync() => await _db.SaveChangesAsync(); }

8. Build the API endpoints

Create controllers for CRUD operations. Example minimal TasksController:

[ApiController] [Route("api/projects/{projectId}/tasks")] public class TasksController : ControllerBase {     private readonly ITaskRepository _repo;     public TasksController(ITaskRepository repo) => _repo = repo;     [HttpGet]     public async Task<IActionResult> Get(int projectId)     {         var tasks = await _repo.GetAllAsync(projectId);         return Ok(tasks);     }     [HttpPost]     public async Task<IActionResult> Create(int projectId, TaskItem input)     {         input.ProjectId = projectId;         await _repo.AddAsync(input);         await _repo.SaveChangesAsync();         return CreatedAtAction(nameof(Get), new { projectId, id = input.Id }, input);     } }

Add validation, DTOs, and AutoMapper for production code to separate API contracts from domain models.

9. Testing

Unit tests: xUnit (free). Use in-memory providers (Microsoft.EntityFrameworkCore.InMemory) to test repositories and services.
Integration tests: use a Dockerized PostgreSQL test database or Testcontainers (free .NET library).
API testing: Postman or curl to exercise endpoints.

Example xUnit test for repository using InMemory DB:

[Fact] public async Task AddTask_IncreasesCount() {     var options = new DbContextOptionsBuilder<AppDbContext>()         .UseInMemoryDatabase(databaseName: "TestDb")         .Options;     using var context = new AppDbContext(options);     var repo = new TaskRepository(context);     await repo.AddAsync(new TaskItem { Title = "Test", ProjectId = 1 });     await repo.SaveChangesAsync();     var tasks = await repo.GetAllAsync(1);     Assert.Single(tasks); }

10. Migrations and schema management

Use EF Core migrations for schema evolution.
For production, run migrations during deployment or via CI pipeline.
Keep migration scripts in source control.

11. Local development productivity tips

Use Docker Compose to run DB + other services.
Enable hot-reload in .NET for faster iteration: dotnet watch.
Seed development data via code or SQL scripts.

Use EF Core logging to inspect generated SQL:


options.EnableSensitiveDataLogging()    .LogTo(Console.WriteLine, LogLevel.Information);

12. Security best practices

Never commit real credentials. Use user secrets for local development and environment variables in CI/CD.
Parameterize queries (ORMs do this by default) to prevent SQL injection.
Use HTTPS for production endpoints and secure cookies or JWT for auth.
Configure database user permissions with least privilege.

13. CI/CD and deployment (free/low-cost options)

GitHub Actions: run build, tests, and migrations. Example workflow steps:
- checkout
- setup-dotnet
- restore, build, test
- run migrations against production DB (with caution) or produce migration scripts
- deploy to a host

Free hosting options (with limits):

Fly.io (free tier, good for containers)
Railway/Heroku alternatives (free credits/tier)
Azure App Service has free tiers for small apps (check current limits)
Deploy to a small VPS (e.g., free-tier cloud instances) and run Docker containers

14. Observability and maintenance

Add logging (Serilog), metrics, and health checks (Microsoft.Extensions.Diagnostics.HealthChecks).
Backups: schedule DB dumps (pg_dump for PostgreSQL) and store off-site.
Monitor slow queries with pg_stat_statements or equivalent.

15. Advanced options and alternatives

Dapper instead of EF Core: simpler, faster for raw SQL, still free.
Use SQLite for single-file apps or desktop scenarios.
Use ORMs like NHibernate if you need features EF lacks.
Consider GraphQL with HotChocolate for flexible client queries.

Example repository structure

TaskManager/
- src/
  - TaskManager.Api/
  - TaskManager.Core/
  - TaskManager.Infrastructure/
- tests/
  - TaskManager.Tests/

Summary

You can build a robust .NET database application entirely with free tools: .NET SDK, a free editor/IDE, a free RDBMS like PostgreSQL, EF Core or Dapper, Docker, and free CI/CD. Plan your data model, use migrations, secure credentials, and automate tests and deployment. Following this path delivers a maintainable, production-ready app without licensing costs.

If you want, I can generate starter code for the full project (controllers, DTOs, DI setup, Docker Compose, and CI workflow).