Articles & tutorials

Host ASP.NET Core and React on IIS: Hosting Bundle, publishing, application pools, HTTPS, SPA routing, zero-downtime deploys and fixing 500.30 errors.

Build a license plate recognition system: labeling data, training a YOLO detector, reading Persian plates, video tracking and running the model in .NET.

Build your first mobile app with React Native and Expo: core components, styling, Expo Router navigation, calling an API, RTL support and publishing.

Minimal APIs vs MVC controllers in ASP.NET Core: syntax, route groups, validation, filters, OpenAPI, testing, performance and which to choose.

Learn MVVM in WPF: data binding, commands, CommunityToolkit.Mvvm source generators, dependency injection, navigation and testable view models.

A practical Core Web Vitals guide: what LCP, INP and CLS measure, how to test them, and concrete fixes for images, fonts, JavaScript and React apps.

Build a Telegram bot in C#: BotFather setup, the Telegram.Bot library, commands, inline keyboards, conversation state and secure webhooks in ASP.NET Core.

Learn Tailwind CSS v4: utility-first styling, responsive and state variants, @theme tokens, dark mode, RTL support and reusable React components.

Understand CORS from the ground up: same-origin policy, preflight requests, cookies and credentials, correct ASP.NET Core setup and common security mistakes.

Protect your API with ASP.NET Core rate limiting: fixed window, sliding window, token bucket and concurrency limiters, per-user limits and 429 responses.

Build robust React forms: controlled vs uncontrolled inputs, validation and error messages, submitting to an API, React Hook Form with Zod, accessibility and handling server errors.

Write tests that catch real bugs: xUnit facts and theories, the Arrange-Act-Assert pattern, mocking with Moq, testing async code, integration tests with WebApplicationFactory and good test design.

A developer's guide to technical SEO: crawling and indexing, rendering SPAs, titles and meta tags, canonical and hreflang, structured data, sitemaps, Core Web Vitals and common mistakes.

Add real-time features with SignalR: hubs, sending to users and groups, strongly typed hubs, authentication, a React client with reconnection, scaling with Redis and common pitfalls.

Build smooth, professional animations in React with GSAP: tweens and timelines, useGSAP cleanup, ScrollTrigger reveals, scrub and pinning, Lenis smooth scrolling, SplitText and performance tips.

Keep data consistent under load: how SaveChanges uses transactions, explicit transactions, execution strategies, optimistic concurrency with RowVersion, isolation levels and safe counters.

Use nullable reference types to catch null bugs at compile time: enabling the feature, ? annotations, null-state analysis, operators, attributes, EF Core and DTO patterns, and migrating old code.

Run background work in ASP.NET Core: BackgroundService, scoped services in workers, PeriodicTimer jobs, Channel queues, graceful shutdown and Windows Services.

Make React apps fast: understand re-renders, measure with the Profiler, use memo, useMemo and useCallback wisely, split code, virtualize long lists, defer work and optimize images.

Learn Docker from a .NET developer's perspective: images and containers, a multi-stage Dockerfile for ASP.NET Core, docker compose with SQL Server, volumes, configuration and production tips.

Build professional right-to-left and bilingual (RTL/LTR) websites: dir and lang, CSS logical properties, mixed-direction text, bidi bugs, fonts, numbers, dates, icons and SEO with hreflang.

Design databases that stay correct and fast: entities and relationships, primary and foreign keys, 1NF to 3NF with examples, denormalization trade-offs, data types and naming conventions.

Master ASP.NET Core configuration: providers and precedence, environment-specific settings, user secrets, environment variables, IOptions vs IOptionsSnapshot vs IOptionsMonitor and validation.

Structure large ASP.NET Core projects with Clean Architecture: Domain, Application, Infrastructure and API layers, the dependency rule, use cases, testing and when it's overkill.

Handle exceptions in C# like a professional: try/catch/finally, exception filters, rethrowing correctly, custom exceptions, using and IDisposable, async exceptions and when not to throw.

A practical TypeScript guide for React: typing props and children, state, events, refs, custom hooks, context, generic components, API responses and useful utility types.

Speed up ASP.NET Core apps with the right cache: in-memory caching, distributed Redis cache, HybridCache, output caching, HTTP caching and safe invalidation strategies.

Fetch server data the right way in React with TanStack Query: queries, query keys, caching and staleTime, mutations, invalidation, optimistic updates, pagination and prefetching.

Learn the design patterns you'll actually use in .NET projects — Strategy, Factory, Decorator, Adapter, Observer, Builder, Options and Mediator — with modern C# examples and DI.

Understand how JavaScript runs async code on a single thread: the call stack, Web APIs, the task and microtask queues, rendering, and why setTimeout(fn, 0) isn't immediate.

An honest look at the Repository and Unit of Work patterns on top of EF Core — when they add value, when they hurt, and a pragmatic implementation for real projects.

Set up production-grade logging in ASP.NET Core: ILogger basics, log levels, structured logging, Serilog sinks, request logging, enrichers, correlation IDs and what never to log.

A practical guide to choosing the right state tool in React — local state, lifting state, Context, reducers, Zustand, Redux Toolkit and server state with TanStack Query.

Make Entity Framework Core fast: AsNoTracking, projections, avoiding N+1, split queries, bulk ExecuteUpdate, compiled queries, pooling, pagination and how to measure with logging.

Understand delegates, Func and Action, lambdas, closures, multicast delegates, events and the EventHandler pattern in C# — and when to prefer interfaces or IObservable.

Handle errors consistently in ASP.NET Core APIs: UseExceptionHandler, IExceptionHandler, ProblemDetails, custom exceptions, mapping to status codes and logging without leaking secrets.

Build multi-page React apps with React Router: route setup, nested layouts with Outlet, URL params, search params, navigation, protected routes, lazy loading and 404 pages.

Protect your apps from the most common attacks: SQL injection, XSS, CSRF, broken access control, IDOR, insecure secrets and misconfiguration — with practical .NET and React fixes.

Master the SQL every developer needs: INNER, LEFT, RIGHT and FULL joins, GROUP BY and HAVING, subqueries, CTEs, window functions and paging — with clear SQL Server examples.

Validate API input properly in ASP.NET Core: data annotations, IValidatableObject, FluentValidation rules, async validation, minimal API filters and consistent ProblemDetails errors.

Learn generics in C# thoroughly: type parameters, generic methods and classes, constraints with where, covariance and contravariance, static abstract members and real-world patterns.

Learn to extract reusable logic into custom React hooks — useFetch, useDebounce, useLocalStorage, useMediaQuery, useOnClickOutside — with design rules and testing tips.

Design APIs developers love: resource naming, HTTP methods, status codes, error format, pagination, filtering, versioning, idempotency and security — with concrete examples.

A practical Git workflow for real projects: branching strategies, writing good commits, merge vs rebase, resolving conflicts, pull requests and how to undo mistakes safely.

Learn asynchronous JavaScript properly: callbacks, Promises, chaining, error handling, async/await, Promise.all vs allSettled vs race, cancellation with AbortController and common mistakes.

Model relationships correctly in Entity Framework Core: navigation properties, foreign keys, Fluent API configuration, delete behaviors, join entities and loading related data.

Understand the ASP.NET Core request pipeline: how middleware runs, why order matters, Use vs Run vs Map, writing custom middleware and real-world examples like timing and correlation IDs.

A practical tour of modern C# (9 to 13): records, init-only properties, pattern matching, switch expressions, primary constructors, collection expressions and raw strings.

The most common useEffect bugs — infinite loops, stale closures, race conditions, missing cleanups and unnecessary effects — with clear fixes and better alternatives.

Learn when to use Flexbox and when to use CSS Grid, with practical patterns for navbars, cards, holy-grail layouts, responsive grids and centering — without media query overload.

Implement secure JWT authentication in ASP.NET Core step by step: issuing tokens, validating them, roles and policies, refresh tokens and the security mistakes to avoid.

Learn how SQL Server indexes work under the hood, how to choose the right columns, read execution plans, build covering indexes and avoid the indexing mistakes that slow databases down.

Learn the five SOLID principles — SRP, OCP, LSP, ISP and DIP — through practical C# examples, with before/after code and advice on when not to over-apply them.

Understand how JavaScript really resolves variables: global, function and block scope, var vs let vs const, hoisting, the temporal dead zone and closures with real examples.

Understand dependency injection in ASP.NET Core: service lifetimes, captive dependencies, keyed services, the options pattern and how DI makes code testable.

Master LINQ in C#: filtering, projection, sorting, grouping, joins, deferred execution, IEnumerable vs IQueryable and the performance traps to avoid.

A practical tour of the essential React hooks — how they work, when to use each one, and the rules and mistakes every React developer should know.

Learn EF Core the right way: DbContext, entities, Fluent API configuration, migrations, CRUD queries, change tracking and the habits that keep your data layer fast.

A step-by-step guide to building a production-ready ASP.NET Core Web API: project setup, controllers, DTOs, EF Core, validation, status codes and Swagger.

Learn how async and await really work in C# — Tasks, the state machine, ConfigureAwait, cancellation, parallelism and the common mistakes that cause deadlocks and slow APIs.