Finish Windows .NET WPF Timekeeping Client with Idle Detection

@AwaisChaudhry

Hi, I understand you already have the API, PostgreSQL DB, React admin, and a WPF client scaffold, and you need the Windows client finished for a small internal trial. I can work on the .NET 8 WPF app, add login, work controls, tray icon/menu, GetLastInputInfo based idle detection, idle popup, auto pause, idle reason flow, SQLite offline storage, and safe sync without duplicate events. I also understand the privacy limits clearly: no screenshots, audio, video, keyboard/mouse content, camera, or mic. I have built WPF desktop/tray apps before, worked with Win32 APIs including idle/activity checks, and used SQLite for offline-first app data and later sync. I can start with the paid test task first, run your current client, verify idle detection, show login/start/idle popup/auto pause, commit code, and send short test notes. Can you share the existing WPF scaffold repo, API docs/endpoints for login and time events, and the expected event payload format for sync? Thanks,

@talhaamin

I am an expert in .net windows and wpf applications and can complete your application. To answer your questions: Have you built WPF tray applications before? Yes i have build many including document processing applications and time tracker app 2. Have you used GetLastInputInfo or similar Win32 APIs? Not GetLastInputInfo but i have handled many win32 apis in past, for mousemovements, clicks etc 3. Have you implemented SQLite offline sync before? Yes have implemented in an offline first POS system 4. Can you start with a small paid test task Yes i can start with a small paid task

@vano101

Hello I am Windows Desktop application developer and I have over 15 years of experience with C#, WPF, Windows API and Visual Studio. Also I have extensive experience with SQLite I built WPF tray app in the past, and I worked with GetLastInputInfo few times, and I know how to detect idle with it. And I am able to start with small paid test task.

@WOFZahid

Hello, I am an experienced and professional WPF developer. I can finish and harden the Windows timekeeping client on your WPF scaffold using C#/.NET 8, GetLastInputInfo, SQLite and your REST API. The app will detect idle time only through GetLastInputInfo and will never capture screenshots, recordings, keyboard/mouse content, camera or microphone — transparent timekeeping, not anti-cheat. I will build the tray icon with Start/Pause-Resume/Stop menu, employee login via your backend, configurable idle threshold (e.g. 5 min), idle popup with auto-pause and the idle-reason prompt (meeting, phone, away, learning, other). SQLite will cache offline events with auto-sync on network return and dedup. To answer your questions: yes to WPF tray apps, yes to GetLastInputInfo via P/Invoke, yes to SQLite offline sync, and yes I can start with the small paid test task (run client, verify idle, demo login/start/idle/auto-pause, submit code + notes). Deliverables: Win 10/11 client, Git source, README, test notes, optional EXE/MSI. Please click on my username to check my profile and past WPF work. Let's discuss in details via chat. Thanks

@seefattechnologi

Hello!^^^^^^I have experience building WPF desktop applications with tray integration, REST API communication, and SQLite-based offline data handling. I have also worked with Win32 APIs, including idle detection mechanisms similar to GetLastInputInfo. I am Asp.net Full stack developer and I can complete and harden your existing .NET 8 WPF client for the internal MVP, including idle tracking, offline sync, tray controls, and API integration. I’m available to start with the paid test task and can provide clean Git commits, documentation, and testing notes.

@axiomswb

Hardening your WPF timekeeping client... I see you need a transparent, privacy-focused Windows desktop MVP that strictly uses GetLastInputInfo for idle detection and seamlessly handles offline REST syncing via SQLite. Here are the direct answers to your 4 questions and exactly how I will execute this: 1 & 2 (Win32 & WPF Tray): Yes, I have built multiple WPF tray applications and will natively hook the GetLastInputInfo Win32 API to trigger your 5-minute idle popup and auto-pause without capturing invasive screen or audio data. 3 (SQLite Offline Sync): Yes, I have extensive experience building robust SQLite offline-first caches that queue events locally and safely push them to your REST API upon network reconnection, guaranteeing zero duplicate syncs. 4 (The Paid Test Task): Yes, I am fully prepared to execute your small paid test task immediately to verify the idle detection and UI flow before we commit to the full build. Quick question: For the REST API integration during the offline sync, do your backend endpoints currently return specific HTTP status codes (like 409 Conflict) if a duplicate event payload is accidentally sent, or should I handle all deduplication logic strictly via SQLite IDs on the client side?

@Jennycreation

As an experienced developer with over 15 years in the field, I am confident in my ability to deliver a high-quality Windows desktop application using the required .NET and C# skills for your timekeeping project. I have extensive expertise with WPF and have developed numerous tray applications, so I am well acquainted with the complexities they involve. My proficiency with Win32 APIs like GetLastInputInfo is impressive and I assure you we can implement the idle detection feature flawlessly. Additionally, I have dealt with SQLite databases extensively before, including offline sync implementation, which aligns perfectly with one of your listed requirements. My team has also been involved in integrating REST APIs seamlessly into applications similar to your back-end API needs. Lastly, given my 100% satisfaction rating and 24x7 availability, my dedication to delivering within budget and timeframe with uncompromising quality will ensure that not only do I provide the exact functionality you require but also updated tests notes, clean source code and an optional EXE/MSI package as stated in your expected deliverables. With all this in mind, I am confident enough for us to proceed with even a small paid test task before kicking off the full project if you prefer.

@ZohaibRoy

⭐⭐⭐⭐⭐ Build a Windows Timekeeping Client Using .NET and WPF ❇️ Hi My Friend, I hope you're doing well. I reviewed your project needs and see you're looking for a Windows desktop developer to complete your timekeeping client. You don’t need to look any further; Zohaib is here to help you! My team has successfully completed over 50 similar projects for Windows applications. I will finish and strengthen your client using the required stack, ensuring it meets all specifications. ➡️ Why Me? I can easily build your Windows timekeeping client as I have 5 years of experience in C#, .NET, and WPF. My expertise includes integrating APIs, working with SQLite, and understanding idle detection through Win32 APIs. I also have a strong grip on other relevant technologies, ensuring a smooth development process. ➡️ Let's have a quick chat to discuss your project in detail and let me show you examples of my previous work. Looking forward to talking with you! ➡️ Skills & Experience: ✅ C# Development ✅ .NET Framework ✅ WPF Design ✅ Win32 API Integration ✅ SQLite Database ✅ REST API Integration ✅ Idle Time Detection ✅ User Authentication ✅ Notification Systems ✅ Code Versioning with Git ✅ UI/UX Design ✅ Offline Data Sync Waiting for your response! Best Regards, Zohaib

@Ranuka

Hello, I’m Ranuka, a Senior .NET Developer with 12+ years of experience in C#, WPF, WinForms, and desktop applications. Answers: Yes, I have built WPF applications with system tray integration and background services. Yes, I have used GetLastInputInfo and other Win32 APIs for idle detection and monitoring. Yes, I have implemented SQLite-based offline storage with automatic sync and duplicate prevention. Yes, I can start with the paid test task immediately. Experienced with .NET 8, REST APIs, SQLite, and offline-first desktop applications. Ranuka Senior .NET Developer 12+ Years Experience

@SJMDEVELOPER

Hi, I’ve developed several WPF tray applications, focusing on user interactivity and performance. I’m familiar with GetLastInputInfo and Win32 APIs for idle detection. For SQLite offline sync, I can design a robust implementation ensuring seamless data handling. I can start with a small paid test task to demonstrate my capabilities and ensure we’re on the same page. I can start with a small paid test task to demonstrate my skills, ensuring you receive quality work. Let’s connect further to discuss the details. I’m ready to dive in! Best, Manoj

@Herculesz

Hi I can finish and harden your Windows .NET 8 WPF timekeeping client based on the existing scaffold. I have experience with WPF tray applications, REST API integration, SQLite local storage, offline sync flows, and Win32 APIs including idle/activity detection patterns. The key technical problem is making idle detection and offline event syncing reliable without creating duplicate records or using invasive monitoring. My solution is to use only GetLastInputInfo for idle state, store every work event locally with sync status/unique IDs, and push pending events safely when the network returns. I can start with the small paid test task by running the client, verifying login, start work, idle popup, and auto pause behavior. I will also implement tray status/menu actions, idle reason capture, auto pause rules, and clean retry logic for pending SQLite events. Code changes will be committed cleanly to Git with README updates and short test notes covering the required workflows. I’ll keep the app transparent and limited to timekeeping only, with no screenshots, recordings, keyboard content, camera, microphone, or hidden tracking. Thanks, Hercules

@vishal1145

Your idle detection logic will fail if users switch to a second monitor or use keyboard-only navigation without moving the mouse. GetLastInputInfo only tracks the last input timestamp - it won't distinguish between a user actively working in Excel versus stepping away for coffee. To ensure accuracy, I'll need clarity on two edge cases: 1. What's your expected behavior when a user is in a long meeting with camera on but not touching keyboard/mouse? Should video conferencing apps (Zoom, Teams) suppress idle detection? 2. Does your PostgreSQL schema support idempotency keys for sync events? If the client crashes mid-sync and retries, I need to prevent duplicate time entries from corrupting payroll data. Here's the implementation approach: - WPF + NOTIFYICON: Build a tray-only application with no main window, using DispatcherTimer to poll GetLastInputInfo every 30 seconds and trigger idle state transitions without blocking the UI thread. - WIN32 INTEROP: P/Invoke GetLastInputInfo with proper error handling for terminal server sessions where the API returns stale data, plus fallback logic for Windows 11 sleep/wake events. - SQLITE OFFLINE QUEUE: Implement a write-ahead log pattern with a pending_events table that stores JSON payloads, then batch-sync via your REST API using exponential backoff to handle network flakiness. - IDLE STATE MACHINE: Track four states (working, idle_detected, paused, stopped) with timestamp transitions stored locally, preventing race conditions where the user clicks Resume while the auto-pause timer fires. - API INTEGRATION: Use HttpClient with retry policies and correlation IDs so your backend can dedupe events if the client sends the same payload twice after a timeout. I've built 8 WPF applications including a field service dispatch tool that ran offline for 12-hour shifts and synced 500+ work orders without data loss. I've used GetLastInputInfo in a kiosk app that detected user abandonment, and I've implemented SQLite sync for a healthcare app that handled HIPAA audit logs during network outages. I'll take the paid test task - I need access to your existing scaffold, backend API endpoint, and a test account. Let's do a 30-minute technical call to review your current code structure and confirm the idle threshold logic before I commit to the full build.

@sharmin283

As an experienced software developer, I have gained substantial knowledge in utilizing the tech stack mentioned in your project description. While my past projects focused on web-admin, API integration, and backend database management, I have also spent significant time building Windows desktop applications including those utilizing WPF and Win32 APIs. Moreover, I understand the importance of using GetLastInputInfo to ensure that idle time is accurately detected while upholding transparency standards, as you have emphasized for this timekeeping app. In terms of offline caching and synchronization using SQLite, this is an area of expertise that is not new to me. In various projects, I had implemented similar features that required robust data storage and management even when users are disconnected from the internet. Consequently, I am confident that I can provide a reliable system where all offline events are saved in SQLite and automatically synchronized when network returns seamlessly, thus minimizing any chance of duplications. Furthermore, my comprehensive understanding of the entire software development lifecycle will ensure not only meeting but exceeding your project expectation. To add value to this process, I am willing to begin with a small paid test task as it will enable us to align our understanding of your project.

@gameprogrammer13

Hello. I am a software engineer with significant experience building robust desktop applications and managing complex system-level tasks. Your project requirements for a reliable timekeeping client align well with my background in creating clean, maintainable tools. I am very comfortable working with system inputs, background processes, and local data persistence to ensure a seamless user experience. I am available to start with a test task immediately.

@Tanmoy236

Greetings! I specialise in C#/.NET desktop development and I’m an expert in building WPF-based system tray applications with reliable Windows API integration and offline-first sync architectures, backed by 9+ years of experience in production internal tools. Here’s how I can help: • Extend your existing .NET 8 WPF scaffold into a stable Windows 10/11 tray application with clean MVVM structure and maintainable architecture • Implement GetLastInputInfo-based idle detection (no screen capture or intrusive monitoring), including configurable thresholds and safe event handling • Build full work tracking flow (start, pause, resume, stop) with tray icon controls and real-time status updates • Develop SQLite-based offline event storage with deduplication logic and reliable REST API sync when connectivity returns • Add user login integration, idle popups with reason capture, auto-pause behavior, and seamless background operation Yes, I have previously built WPF tray tools, Windows service-style utilities, and enterprise desktop apps using Win32 APIs including GetLastInputInfo for idle tracking. I’ve also implemented SQLite-based offline-first sync systems for unreliable network environments, ensuring no duplicate event submission and safe recovery. I’m comfortable starting with your paid test task. It’s actually the right approach to validate idle detection, tray behavior, and sync flow before scaling the full client.

@yuliussmayoru

Hello! I’ve built Windows desktop tools in C# where the tricky part was not the UI itself, but making background behavior reliable, lightweight, and easy for real users to live with, so a transparent WPF timekeeping client like this is very much in my comfort zone. I like that the app is explicitly framed as transparent timekeeping rather than surveillance software, because that usually leads to a cleaner product and a better user experience for the internal trial. I’m comfortable with tray-based desktop applications, Win32 interop from WPF, REST integration, local persistence, and the kind of state handling needed for start, pause, resume, stop, idle popup flow, auto-pause, and reconnect sync logic. I can also start with the small paid test task first, which is a good way to confirm the scaffold, the idle detection behavior, and the existing API integration before moving into the full implementation. Answers: 1. Yes, I have worked on WPF applications with tray behavior and background status handling. 2. Yes, I’m comfortable using Win32 APIs from C#, including input and system-state related interop patterns. 3. Yes, I’ve implemented local persistence and offline-to-online sync flows, including duplicate-prevention logic. 4. Yes, I can start with the paid test task first.

@wasifmuneer

Hi there, I’d be happy to discuss your project—feel free to start a chat anytime. I’m a full-stack developer with solid experience building scalable web and desktop applications, and I’m confident I can deliver your project efficiently and on time. I also have strong exposure to modern technologies including Web3 concepts, DevOps practices, and automation. I’m a Kubernetes enthusiast with hands-on experience using Docker containers and deploying applications on Linux servers. My expertise includes: MERN / MEAN Stack (development + team management) .NET Core APIs with Angular, including D3.js data visualizations Azure Logic Apps, SharePoint, and workflow automation (PowerApps familiarity) Salesforce development with Apex, Visualforce, and integrations via .NET APIs DevOps basics, containerization, and application hosting on Linux Automation workflows and AI-based tools to improve efficiency I bring a problem-solving mindset and full project lifecycle experience—from development to deployment. Looking forward to hearing from you and answer to your all questions in description is YES. Thank you!

@mobiwebsolutions

✋ Hi There!!! ✋ The Goal of the project:- FINISH AND HARDEN A WINDOWS WPF TIMEKEEPING CLIENT WITH IDLE DETECTION, OFFLINE SYNC, AND REST API INTEGRATION FOR RELIABLE EMPLOYEE TRACKING. I have carefully reviewed the requirement for a WPF desktop client using GetLastInputInfo idle detection, tray controls, SQLite offline storage, and stable API synchronization for an internal MVP system. I can deliver a clean, reliable implementation that fits production use and matches your existing backend structure. 1. WPF tray application with login, start, pause, resume, stop and GetLastInputInfo idle detection 2. SQLite offline storage with REST API sync and duplicate event prevention 3. Idle popup flow with auto pause, user reason capture, and notification handling I will include UI design, database management, testing, and full source code delivery at project completion. I have 9+ years experience as a full stack developer working on Windows desktop applications, API integrations, and offline sync systems. I have completed similar WPF time tracking and automation projects with backend synchronization and desktop tooling. Looking forward to chat with you for make a deal Best Regards Elisha Mariam!

@danielboggs

Hello, This project is a great match for my background. I have extensive experience developing desktop applications with C#, .NET, WPF, Win32 APIs, SQLite, REST API integrations, and offline-first synchronization systems. I've built business applications that include system tray functionality, background services, local data storage, idle/activity monitoring, and reliable sync mechanisms for intermittent network environments. For your MVP, I can quickly get up to speed with the existing WPF scaffold, validate the GetLastInputInfo implementation, complete the remaining functionality, harden the client for real-world usage, and ensure clean synchronization between SQLite and your backend API while preventing duplicate events. Answers to your questions: 1: Yes, I have built multiple WPF applications with system tray integration and background monitoring features. 2: Yes, I have worked with Win32 APIs, including idle and activity detection mechanisms. 3: Yes, I have implemented SQLite-based offline storage and synchronization systems with conflict and duplicate prevention. 4: Yes, I can start with the paid test task immediately. I can begin by running the existing client, verifying idle detection, implementing or validating the login and work-state flow, and submitting tested code changes with clear documentation. Best regards,
Daniel