You have opted out of job matches in .
To undo this, go to the 'Skills and Interests' section of your preferences.
Posted about 1 year ago
Requirements and responsibilities
At Softgic, we work with the coolest, with those who build, with those who love what they do, with those who have 100 in attitude, because that's our #Cooltura. Join our purpose of making life easier with technology and be part of our team as a Principal C#/.Net FullStack Engineer - (75% BE / 25% FE).
🟨 Requirement:
- 5+ years of experience using C#/.NET core.
- Experience creating Blazor components and using components libraries eg: Dev Express.
- Tailwind CSS / MUI components - desired.
- Entity Framework or any other ORM experience.
- Experience building integrations with 3rd party services is a must.
- Experience building solutions following the MVVM architecture pattern.
- Experience with Continuous Integration and Delivery (CI/CD), preferably with Azure DevOps.
- Excellent interpersonal and teamwork skills to facilitate collaborative problem solving amongst team members.
- Professional software engineering experience applying best practice software engineering including separation of concerns, high cohesion, low coupling, modularization, encapsulation and information hiding, interfaces, and dependency injection.
- Professional software engineering experience applying object-oriented programming (OOP) principles such as SOLID, DDD and TDD.
- Experience with MS SQL.
- Proven experience delivering solutions for complex distributed systems in Azure.
- Docker and containerization.
- Nice To Have: Understanding of Visual Basic for applications code.
- Experience with small teams that move fast - all members are expected to achieve maximum results with minimal direction.
- Proven experience meeting software deliverable deadlines.
🟨 Tools and Tech Stack
C#, .NET Core 8+, Azure DevOps, Dev Express or other grid controls, Active Directory authentication, Nuget packages. Blazor (highly desirable)
🟨 Responsibilities
1. You Are an Agile Team Member: As part of a self-organizing team, you contribute to success by:
- Collaborating with the Product Owner to refine backlog and break down stories into small functional slices.
- Maintaining commitment and displaying ownership in tasks.
- Encouraging a positive team culture by supporting innovation and new ideas.
- Proactively seeking skill development and learning opportunities.
- Asking for assistance when facing challenges.
- Balancing best practices with business value in decision-making.
- Ensuring timely completion of committed stories/tasks within sprints.
2. You Are Also the Principal Engineer
As the premier developer on the team, you engineer scalable, high-quality solutions that align with strategic architectural goals.
3. Principal Accountability | Technical Sprint Planning
- Owns technical design for sprints, including high-level flow diagrams, ERDs, and service contracts.
- Ensures team understanding and adherence to technical plans.
- Designs solutions with testability, modularity, and determinism in mind.
- Maintains awareness of dependent projects and their impact on design.
- Guides team members in defining clear, small, and testable tasks.
- Engages in design discussions with the team and higher-level architectural groups.
- Aligns team direction with enterprise architectural vision.
- Defines technical acceptance criteria for stories where necessary.
- Owns and manages the technical backlog, collaborating with the PO for prioritization.
4. Principal Accountability | Software Development
- Clearly communicates solution details to the team.
- Encourages collective code ownership through CI and frequent check-ins.
- Implements and enforces unit testing with a goal of 80%+ code coverage.
- Continuously addresses technical debt and escalates when necessary.
- Acts as a mentor and resource for junior developers.
- Oversees the merge process and code integration.
- Conducts root cause analysis on defects to ensure proper resolutions.
- Maintains a local development environment to reduce deployment risks.
5. Principal Accountability | Software Inspection
- Ensures daily code check-ins and enforces best practices.
- Uses static code analysis tools to identify vulnerabilities, anti-patterns, and defects.
- Monitors unit test results and maintains accountability for quality.
- Evaluates cyclomatic complexity and initiates refactors when necessary.
- Ensures transparency in the code inspection process through CI and reporting.
- Enforces the team’s Definition of Done and reviews QA test plans for technical coverage.
- Conducts internal and cross-team code reviews.
6. Principal Accountability | Release Planning
- Adheres to and enforces a well-defined code promotion process.
- Supports and ensures timely releases with adherence to release activities.
- Resolves defects efficiently and identifies tactical risks.
- Ensures operational readiness for deployment, including dry-runs and production rollouts.
- Coordinates with infrastructure teams for access control, service accounts, and permissions.
- Prepares clear deployment documentation detailing changes and target environments.
7. Principal Accountability | Community & Leadership
- Promotes a strong developer community within and beyond the team.
- Leads formal and informal knowledge-sharing sessions (e.g., lunch & learn).
- Acts as a bridge between the team and management to ensure necessary skills are present.
- Encourages continuous learning, self-study, and best practice adoption.
Optionally, you can add more information later (benefits, pre-screening questions, etc.)