Select your current position
Pick a role and level — we'll show the growth path, skills and gap analysis.
Development path
Junior
0-2 years
Responsibility: Completing tasks under the guidance of senior colleagues. Learning the codebase, standards, and team processes. Writing code to spec, fixing simple bugs, writing tests.
Key skills:
Middle
2-5 years
Responsibility: Independently developing features from decomposition to deployment. Participating in code review. Optimizing performance. Mentoring junior developers. Taking part in architecture discussions.
Key skills:
Senior
5-8 years
Responsibility: Designing the architecture of components and services. Solving complex technical problems. Managing technical debt. Code review as a quality gatekeeper. Mentoring middle developers. Choosing technologies for new tasks.
Key skills:
Lead / Staff
7-12 years
Responsibility: Technical leadership of a team or area. Designing system architecture. Coordinating with other teams. Establishing standards and best practices. Participating in hiring. Planning the technical roadmap.
Key skills:
Principal
10+ years
Responsibility: Technical strategy at the company or domain level. Cross-organizational influence. Solving systemic business problems through technology. Mentoring lead engineers. Publicly representing the company.
Key skills:
Gap analysis: skills to develop
To reach the next level you'll need to develop:
Implements auto-update through Velopack or AutoUpdater.NET. Configures delta updates, signature verification through Authenticode. Works with update channels (stable/beta). Integrates update UI into application.
Conducts code review for C#/.NET desktop code. Checks async/await correctness, MVVM adherence, memory management. Provides constructive feedback. Reviews XAML.
Profiles .NET desktop through dotnet-trace and PerfView. Analyzes JIT compilation and GC pause times. Uses BenchmarkDotNet for micro-benchmarks. Optimizes hot paths.
Configures MSIX packaging with Windows Application Packaging Project. Creates WiX installers for enterprise. Signs packages through signtool. Automates packaging through MSBuild targets.
Applies Git rebase, cherry-pick, bisect. Configures Git hooks with dotnet-format pre-commit. Works with Git submodules for shared libraries. Resolves merge conflicts in .csproj and XAML.
Optimizes startup through lazy loading, ReadyToRun, trimming. Reduces UI render latency through VirtualizingStackPanel. Uses async rendering for heavy UI. Profiles with PerfView.
Applies MVVM with ObservableValidator for validation. Uses IMessenger (WeakReferenceMessenger) for inter-ViewModel communication. Organizes navigation through INavigationService. Implements async commands.
Structures tests by modules. Uses Moq/NSubstitute for dependency mocking. Introduces code coverage through coverlet. Applies FluentAssertions for readable assertions.
Independently develops WPF/WinUI applications with MVVM through CommunityToolkit.Mvvm. Creates custom UserControl and ControlTemplate. Works with DataTemplate, IValueConverter. Uses Navigation through Frame.
Optimizes LINQ chains for large collections through Span<T> and ArrayPool. Implements traversal algorithms for TreeView models. Profiles bottlenecks through BenchmarkDotNet.
Applies IAsyncEnumerable for streaming data. Implements async initialization through AsyncLazy. Uses Polly for retry/circuit-breaker in async operations. Handles async exceptions through ExceptionDispatchInfo.
Configures StyleCop, SonarAnalyzer for static analysis. Uses Roslyn analyzers and code fixes. Applies code metrics (cyclomatic complexity, coupling). Writes self-documenting code with XML comments.
Implements concurrent operations through Task Parallel Library (TPL). Uses CancellationToken for operation cancellation. Applies SemaphoreSlim, lock, ReaderWriterLockSlim for synchronization. Works with Channels.
Implements MVVM with Command, Mediator (MediatR), Observer. Applies Strategy through DI for swappable algorithms. Uses Decorator for cross-cutting concerns (logging, caching). Understands Unit of Work with EF Core.
Designs classes following SOLID in WPF/WinUI context. Uses dependency injection through constructor injection. Applies interfaces for testability. Understands pattern matching with is/switch expressions.
Profiles .NET desktop through dotMemory or VS Memory Profiler. Analyzes allocation timeline, finds retention paths. Uses EventPipe for lightweight profiling in production.
Creates custom ObservableCollection with filtering/sorting through CollectionViewSource. Uses ImmutableList<T>/ImmutableDictionary for thread-safe data. Applies ReadOnlyObservableCollection for encapsulation.
Manages memory through Span<T>, Memory<T>, ArrayPool<T>. Analyzes GC pressure through dotnet-counters. Optimizes struct vs class selection for hot paths. Uses WeakReference for cache patterns.