Every professional in our network passes rigorous vetting assessments and only the top 0.5% make the cut. From full-stack developers to growth marketers and accountants, you’ll only meet the best of the best on South.
.svg){kind=logo}
.NET is a free, open-source, cross-platform development platform maintained by Microsoft and the broader .NET community.
It includes several major parts:
Developers can use .NET to build many different kinds of applications from the same underlying platform.
A web application might use:
C#
↓
ASP.NET Core
↓
Entity Framework Core
↓
PostgreSQL
↓
Azure
A desktop application might instead use:
C#
↓
WPF
↓
SQL Server
.NET provides the underlying runtime, libraries, tooling, and application frameworks supporting those different workloads.
This distinction is important.
Modern .NET is:
Starting with .NET 5, Microsoft dropped the “Core” name and simply calls the platform .NET.
Modern releases include:
For new applications, modern .NET should generally be the starting point.
.NET Framework is the older Windows-specific implementation.
It remains important because many companies still operate applications built with technologies such as:
Some of those applications continue running successfully and don't require immediate replacement.
The architectural question is therefore often:
Should we maintain the existing .NET Framework application, modernize it gradually, or migrate selected workloads to modern .NET?
.NET supports a wide variety of software.
ASP.NET Core can build:
.NET is widely used for:
.NET applications can run across:
Companies can use .NET to build independently deployable services around business domains such as:
.NET remains common in business systems involving:
Companies can create internal software around:
.NET supports Windows desktop development through technologies such as:
.NET MAUI supports applications targeting platforms such as:
.NET Worker Services can run:
.NET can also provide the application layer around AI systems.
Developers may build:
The AI service itself can sit behind normal .NET application architecture involving authentication, databases, queues, and observability.
C# is the primary programming language associated with modern .NET.
The two terms aren't interchangeable.
C# is a programming language.
.NET is the platform on which C# applications commonly run.
Developers use C# for:
Strong .NET expertise usually requires strong C# fundamentals.
C# supports:
Good application architecture uses these tools intentionally rather than creating inheritance hierarchies for every problem.
Generics allow developers to create reusable code while preserving type safety.
They appear extensively throughout .NET collections, libraries, and frameworks.
Language Integrated Query, or LINQ, provides a consistent syntax for querying collections and other data sources.
Developers may use LINQ with:
A LINQ expression against EF Core can eventually become SQL.
That makes understanding the generated query important for performance.
Nullable reference types help developers represent whether reference values are expected to be null.
They can make nullability problems more visible during compilation.
Modern C# provides extensive pattern-matching capabilities for writing expressive conditional logic.
Records are useful for selected data-oriented types where value-like semantics are helpful.
Asynchronous programming is central to modern .NET application development.
It appears frequently around:
Understanding async properly helps applications handle I/O efficiently.
The .NET runtime executes managed application code.
It provides capabilities including:
.NET automatically manages much of application memory.
Developers still need to understand memory behavior because unnecessary allocations can create:
The Just-In-Time compiler converts managed code into machine code for the current environment.
Modern .NET continues to improve JIT optimization and runtime performance.
Native Ahead-of-Time compilation allows selected .NET applications to compile directly into native binaries.
Potential advantages can include:
Native AOT also introduces compatibility considerations.
It should be chosen according to the application rather than enabled automatically.
ASP.NET Core is .NET's modern web framework.
Developers use it for:
ASP.NET Core is cross-platform and designed for modern hosting environments.
Middleware creates the HTTP processing pipeline.
A request may move through:
Request
↓
Exception handling
↓
Authentication
↓
Authorization
↓
Routing
↓
Endpoint
Middleware can handle concerns such as:
The order matters because each component can affect what happens later in the pipeline.
Dependency injection is built into modern .NET application development.
A service might depend on:
IEmailSender
rather than constructing a specific email provider directly.
The runtime's service container can then provide the implementation.
Benefits can include:
Developers should understand common lifetimes such as:
Choosing the wrong lifetime can create subtle correctness and concurrency problems.
ASP.NET Core supports controller-based and Minimal API approaches.
A typical API may handle:
Good API architecture also considers:
Minimal APIs provide a more concise way to define HTTP endpoints.
They can work particularly well for:
Larger applications can still structure Minimal APIs into organized modules and services.
“Minimal” describes the programming model rather than requiring the application architecture to remain simple.
.NET APIs can expose OpenAPI documents describing:
These contracts can support:
Modern ASP.NET Core includes first-party OpenAPI capabilities.
ASP.NET Core can support authentication using approaches such as:
Authentication establishes who the user is.
Authorization determines which actions that user may perform.
Applications may use:
Security should be enforced on the server rather than relying on the user interface to hide restricted functionality.
Blazor allows developers to build interactive web user interfaces with .NET and C#.
Modern Blazor applications can combine:
Blazor can be valuable for teams that want to use C# across a larger portion of the application stack.
React, Angular, and Vue remain common alternatives for frontend-heavy applications.
SignalR provides real-time communication for .NET applications.
It may support:
SignalR abstracts much of the connection-management work around technologies such as WebSockets.
gRPC supports strongly typed service-to-service communication.
It can be useful for:
gRPC commonly uses Protocol Buffers to define service contracts.
Entity Framework Core, or EF Core, is Microsoft's modern object-relational mapper for .NET.
It allows developers to work with relational databases using:
EF Core supports database platforms such as:
and others through database providers.
DbContext represents a session with the database.
It manages areas such as:
In web applications, it is commonly used with scoped lifetime patterns.
Developers can express database queries with LINQ.
EF Core translates supported expressions into SQL.
For example:
C# LINQ
↓
EF Core
↓
SQL
↓
Database
Developers should understand this translation because an innocent-looking LINQ expression can sometimes generate inefficient SQL.
Migrations track schema changes in application code.
They may:
Production database migrations should still be reviewed carefully around:
EF Core can track changes made to entities and translate them into database updates.
Tracking is useful when data will be modified.
Read-heavy queries may sometimes benefit from no-tracking approaches.
Related information can be loaded through mechanisms such as Include.
Developers should still inspect the resulting query to avoid loading unnecessary information.
Dapper is a lightweight object mapper frequently used in .NET applications.
It provides less abstraction than EF Core and gives developers more direct control over SQL.
A team might choose:
EF Core for most application data access
and:
Dapper for selected performance-sensitive queries.
The choice depends on the application's data-access requirements.
.NET applications can work with many database technologies.
SQL Server is common in Microsoft-oriented application stacks.
PostgreSQL is widely used with modern cross-platform .NET.
MySQL can also support .NET applications through compatible providers.
Cosmos DB may appear in applications needing selected distributed or NoSQL patterns.
Redis can provide:
Strong .NET Developers should understand the database they're using rather than assuming the ORM removes the need for database knowledge.
SQL remains important even when EF Core is the primary data-access layer.
Developers should understand:
Explore SQL for deeper coverage of relational querying and optimization.
Applications use transactions when related database changes need to succeed or fail as one unit.
Examples include:
Distributed architectures create additional transaction challenges when multiple services or data stores are involved.
.NET Worker Services provide a structured approach to long-running processes.
Use cases include:
Hosted services can also run inside ASP.NET Core applications for selected workloads.
.NET applications frequently use technologies such as:
Messaging can decouple application components.
For example:
Order API
↓
Queue
↓
Fulfillment Worker
Developers need to design around:
MassTransit is a popular .NET abstraction for distributed application messaging.
It can work with brokers such as:
Applications with extensive messaging may use frameworks like MassTransit to standardize consumers, retries, sagas, and other patterns.
Caching can reduce expensive repeated work.
.NET applications may use:
A good caching strategy answers:
Modern .NET provides a flexible configuration system.
Applications may receive configuration from:
Sensitive credentials should remain outside source-control repositories.
The Options pattern maps configuration into strongly typed classes.
This can make application configuration easier to validate and consume.
.NET integrates with structured logging abstractions.
Applications may send logs to platforms such as:
Logs should provide useful context without exposing sensitive information.
Modern .NET applications can use OpenTelemetry for:
This provides a vendor-neutral observability model.
A request may be traced across:
API
↓
Database
↓
External service
↓
Queue
making distributed failures easier to diagnose.
xUnit is widely used for .NET automated testing.
NUnit remains common across many .NET environments.
Microsoft also provides MSTest.
The testing framework matters less than having useful automated coverage.
Unit tests validate isolated logic.
Integration tests may verify:
ASP.NET Core provides tooling for hosting applications in test environments so endpoints can be exercised more realistically.
Mocking libraries can replace dependencies during selected tests.
Teams should avoid mocking every internal method simply to make tests pass.
Tests should protect important behavior.
Modern .NET provides extensive performance tooling.
Developers may investigate:
Useful tooling can include:
dotnet-countersdotnet-tracedotnet-dumpBenchmarkDotNet allows developers to create repeatable microbenchmarks for .NET code.
It can be useful when comparing performance-critical implementation choices.
Microbenchmarks shouldn't replace measuring the full production application.
Incorrect asynchronous code can create:
Developers should understand concepts such as:
TaskCancellation tokens allow operations to respond when work is no longer needed.
Examples include:
Propagating cancellation through database and HTTP operations can prevent unnecessary work.
Modern .NET applications need standard application-security practices.
Important areas include:
ASP.NET Core provides data-protection APIs used by parts of the framework for protecting sensitive application data.
Production secrets may live in platforms such as:
Local development can use environment-specific approaches without committing secrets to Git.
.NET applications work well inside containers.
A typical workflow might look like:
Source code
↓
dotnet publish
↓
Container image
↓
Container platform
Developers should consider:
.NET services can run on Kubernetes.
Kubernetes may provide:
It should be adopted when the broader application and organization benefit from Kubernetes rather than simply because the application uses containers.
Azure has deep integration with .NET.
Applications may use:
Explore Azure for deeper coverage of the Microsoft cloud platform.
.NET also runs extensively on AWS.
Applications may use:
Modern .NET isn't tied to Azure.
Aspire provides tooling and patterns for building, developing, and operating distributed applications.
It can coordinate dependencies such as:
Aspire is particularly useful for complex local development and cloud-native application environments.
It should be treated as part of the broader distributed-application ecosystem rather than a requirement for every .NET project.
.NET MAUI supports cross-platform applications across:
Teams can share substantial application code across platforms while still adapting the interface and behavior where needed.
Windows Presentation Foundation remains relevant for Windows desktop applications.
It's common in established:
Modernization doesn't automatically require replacing every WPF application.
Windows Forms is another mature Windows desktop framework in the .NET ecosystem.
It remains relevant for existing line-of-business applications and selected new internal tools where its development model fits.
Many organizations operate mature .NET Framework applications.
Modernization may involve:
A complete rewrite is rarely the only option.
Incremental migration can reduce risk.
Migration planning should examine:
Some libraries may migrate easily.
Others may require substantial redesign.
Tools can assist with analysis, while experienced engineering judgment is still needed for application-specific decisions.
A modern .NET SaaS application might look like:
React or Blazor frontend
↓
ASP.NET Core API
↓
Application services
↓
EF Core
↓
PostgreSQL
↓
Redis cache
↓
Service Bus
↓
Background Worker
↓
External integrations
Azure or AWS runs the application.
OpenTelemetry provides traces and metrics.
GitHub Actions deploys changes.
.NET becomes the application platform connecting code, APIs, data, cloud infrastructure, and production operations.
A .NET Developer builds applications, APIs, services, and other software using the .NET platform.
An ASP.NET Developer specializes more narrowly in .NET web development.
A Back-End Developer may use .NET while focusing broadly on server-side application engineering.
A Full-Stack Developer may combine ASP.NET Core with:
Software Engineers may use .NET across backend, desktop, cloud, or distributed systems.
An Azure Developer may build cloud applications using .NET alongside Microsoft Azure services.
Modern .NET is:
.NET Framework is:
Use modern .NET for most new development.
Maintain .NET Framework expertise when existing applications depend on it.
“.NET Core” is the former name for Microsoft's cross-platform .NET implementation.
Beginning with .NET 5, Microsoft removed “Core” from the product name.
Modern applications should therefore be described as:
.NET 8
.NET 9
.NET 10
rather than “.NET Core 10.”
ASP.NET Core and Entity Framework Core retain “Core” in their names.
.NET is the broader application platform.
ASP.NET Core is the web-development framework within .NET.
You can use .NET without ASP.NET Core for:
C# is a programming language.
.NET is the runtime and development platform used to execute C# applications.
C# can therefore be viewed as one central skill inside the broader .NET ecosystem.
.NET and Java both support:
The right choice often depends on:
.NET and Node.js can both support APIs, SaaS products, and distributed services.
Node.js provides a JavaScript/TypeScript server ecosystem.
.NET provides a C#-centered platform with deep tooling around ASP.NET Core, EF Core, and the broader Microsoft ecosystem.
Both can run cross-platform and in containers.
.NET is Microsoft's free, open-source, cross-platform development platform for building web, cloud, desktop, mobile, and distributed applications.
.NET 10 is the current Long Term Support generation in 2026.
Production teams should choose supported releases according to Microsoft's lifecycle and their own upgrade strategy.
No.
.NET Framework is the older Windows-only implementation.
Modern .NET is cross-platform and is the primary platform for new development.
The technology continues as modern .NET, but Microsoft dropped the “Core” product name beginning with .NET 5.
ASP.NET Core and Entity Framework Core still use “Core” in their names.
ASP.NET Core is .NET's modern framework for building web applications, APIs, real-time applications, and other web workloads.
EF Core is an object-relational mapper for .NET that allows developers to work with relational databases through C#, LINQ, and model configuration.
C# is the most common.
.NET also supports languages such as F# and Visual Basic.
Yes.
Modern .NET runs across Windows, Linux, and macOS.
Yes.
Modern .NET applications can run on AWS, Azure, Google Cloud, containers, and other compatible infrastructure.
.NET Developers, ASP.NET Developers, Back-End Developers, Full-Stack Developers, Software Engineers, and Azure Developers can all work with the .NET ecosystem.
Understanding .NET helps you identify whether your software needs stronger C#, ASP.NET Core, EF Core, APIs, cloud development, performance, distributed systems, or legacy modernization expertise.
If you need someone dedicated to building and maintaining these applications, South can help you hire .NET Developers in Latin America.
Schedule a free call and Find remote software development talent in Latin America with South.
