PromptBase
PromptBase SelectGet Select
Close icon
General
Home
Marketplace
Create
Hire
Login
Chat
Sell
Explore

Prompt Details

Model
Chat - (gpt-5.6)
Token size
9,109
Example input
[English]: English
Example output
PROMPTFORGE — FREELANCER WORKSPACE WEB APP ROLE Act as a senior product architect, UX/UI designer, SaaS systems architect, security engineer, and full-stack technical lead. You are responsible for transforming the product requirements below into a production-grade web application plan and implementation. Make professional technical and design decisions where the requirements do not specify an exact implementation, but do not invent user-specific business requirements. Prioritize usability, architectural soundness, security, maintainability, accessibility, and implementation realism over unnecessary feature complexity. --- PRIMARY OBJECTIVE Design and prepare a modern SaaS freelancer workspace that helps growing freelancers manage: - clients - projects - milestones - tasks - deadlines - workload - time tracking - billable/non-billable hours - invoices - recurring invoices - payment status - files - reminders - reports - project communication - client communication The result must be detailed enough to function as both: 1. a professional product blueprint for designers/developers, and 2. an authoritative specification that a coding AI can use to implement the application. The product should remain focused on freelancer operations in V1 while using an architecture that can support broader business-management capabilities in future versions. --- PRODUCT DIRECTION Build a desktop-first web application with a mobile companion experience. Desktop Optimize for complex freelancer workflows: - dashboard - project management - milestone planning - task management - Kanban - calendar - workload planning - time tracking - invoicing - reports - file management - client management - communication - settings Mobile Optimize for quick actions rather than reproducing every desktop workflow: - task/status updates - deadline checking - calendar - timer controls - notifications - reminders - quick client/project access - lightweight communication - invoice/status visibility where appropriate The responsive strategy should be deliberate rather than simply shrinking the desktop UI onto smaller screens. --- PRIMARY USERS Freelancer The primary user manages their own: - clients - projects - milestones - tasks - time - workload - invoices - files - communications - deadlines - reports Small-Team-Ready Architecture V1 should primarily serve an individual freelancer while the underlying architecture accommodates adding collaborators later. Design the data model and authorization boundaries so future team members can be introduced without requiring a fundamental rewrite. Do not unnecessarily turn V1 into a full enterprise collaboration platform. Client Clients receive access through a dedicated client portal. Clients should be able to: - view relevant projects - view milestones/deadlines - view relevant files - view invoices - see invoice/payment status - communicate with the freelancer - participate in appropriate project communication Client access must be isolated from the freelancer's private workspace and controlled through explicit permissions. --- PRODUCT PRINCIPLES Design the application around these principles: 1. Clarity over feature density 2. Fast access to important work 3. Strong information hierarchy 4. Minimal cognitive overhead 5. Professional SaaS quality 6. Consistent interaction patterns 7. Secure handling of client and financial information 8. Accessible by default 9. Reusable architecture 10. Future extensibility without premature complexity The experience should feel like a polished professional productivity product rather than an accounting application or generic project-management clone. --- CORE INFORMATION ARCHITECTURE Design the product around an appropriate hierarchy such as: Workspace → Client → Project → Milestone → Task Relevant entities should also connect to: - time entries - files - comments - messages - invoices - payments/payment records - reminders - notifications - reports Define the relationships explicitly. Avoid duplicated sources of truth. --- CORE FEATURES 1. Dashboard Create a useful operational dashboard showing information such as: - current projects - project status - upcoming deadlines - milestone deadlines - overdue work - task priorities - workload - tracked time - billable hours - outstanding invoices - overdue invoices - upcoming recurring invoices - recent client activity - notifications/reminders The dashboard should help answer: What requires my attention right now? Do not overload it with low-value metrics. --- 2. Client Management Provide a structured client area containing relevant: - client profile - contact information - associated projects - invoices - payment status - files - communications - activity history - notes where appropriate Separate private freelancer information from information exposed through the client portal. --- 3. Project Management Projects should support: - project name - client - description - status - start date - target/end date - budget or financial information where appropriate - milestones - tasks - files - time entries - comments - client communication - related invoices - activity history Define sensible project states and transitions. --- 4. Milestones Projects must support milestones. Milestones should allow: - name - description - status - target date - associated tasks - progress - relevant files - comments - client visibility where appropriate Tasks should be associable with milestones. Milestone deadlines must influence relevant dashboard, calendar, reminder, and workload views. --- 5. Task Management Support: - task title - description - project - milestone - status - priority - assignee architecture - due date - estimated effort - tracked time - billable status where relevant - comments - attachments/files - activity history Provide a Kanban view with sensible workflow states. Also provide appropriate list/detail views. Define useful empty, loading, error, overdue, completed, and archived states. --- 6. Calendar Provide a unified calendar experience for relevant: - task deadlines - milestone deadlines - project dates - reminders - other supported scheduling information Make important deadline conflicts and overdue items easy to identify. The calendar should complement, not replace, project/task management. --- 7. Workload Management Help freelancers understand their upcoming workload. Use relevant signals such as: - upcoming due dates - estimated task effort - assigned work - active projects - tracked time - overdue work Do not create artificial productivity metrics without a meaningful purpose. If the available information is insufficient for accurate capacity calculations, make the limitation explicit rather than presenting false precision. --- 8. Time Tracking Implement advanced time tracking supporting: - start/stop timer - manual time entries - editing entries - project association - task association - billable/non-billable classification - hourly rates - notes - date/time information - activity summaries Where appropriate, calculate: - billable hours - non-billable hours - billable value - invoiceable time Design the data model so time entries remain auditable. Avoid claiming that automatically tracked time is inherently accurate if the system cannot verify it. --- 9. Invoicing Implement professional invoicing functionality supporting: - invoice creation - invoice numbering - client association - project association where appropriate - line items - quantities - rates - taxes - discounts - payment terms - due dates - notes - invoice status - recurring invoices - invoice reminders - PDF generation - payment records/status - overdue tracking Define a clear invoice lifecycle. For example, distinguish appropriately between states such as: - draft - issued/sent - viewed where supported - partially paid - paid - overdue - cancelled/void Do not assume that every payment provider or integration will expose identical payment states. --- 10. Payment Architecture V1 should be payment-integration-ready rather than provider-dependent. Define: - payment-related domain entities - payment status model - transaction references - webhook/event boundaries - idempotency requirements - reconciliation boundaries - provider abstraction - security considerations Do not hard-code the architecture around one payment provider unless there is a strong technical reason. Actual payment-provider implementation may remain optional. Never store sensitive payment credentials or card data unnecessarily. --- 11. Recurring Invoices Support recurring billing logic including: - recurrence schedule - start/end conditions - next invoice date - invoice template/data - client association - project association where relevant - active/paused/cancelled states - generation rules - reminder behavior Clearly distinguish a recurring-invoice definition from the individual invoices it generates. --- 12. Files Provide file management associated with relevant: - clients - projects - milestones - tasks - messages Define: - upload behavior - metadata - access permissions - file visibility - validation - size/type restrictions - storage abstraction - deletion behavior - authorization checks Do not expose private freelancer files through the client portal by default. --- 13. Communication Implement two complementary communication systems. Contextual collaboration Provide comments associated with relevant: - projects - milestones - tasks - files Client messaging Provide dedicated client conversation threads. Support appropriate: - messages - timestamps - read/unread state - attachments - notifications - conversation permissions - project/client association Keep private internal comments separate from client-visible communication. --- 14. Notifications and Reminders Support useful notifications around: - approaching deadlines - overdue tasks - milestone deadlines - invoice due dates - overdue invoices - client messages - relevant project activity - recurring invoice events Avoid notification spam. Design notification preferences and delivery architecture so additional channels can be introduced later. --- 15. Reports Provide useful operational and financial reporting. Potential reports include: - billable vs non-billable time - project time - client time - invoice status - outstanding receivables - revenue/invoiced totals where supported by the data - project performance - workload summaries Do not present accounting-grade conclusions unless the underlying data and scope genuinely support them. Clearly distinguish operational reporting from formal accounting. --- AUTHENTICATION AND ACCESS Use modern SaaS authentication supporting: - email/password - social login - email verification - password reset - secure session management - optional two-factor authentication Design authorization separately from authentication. Use role/permission boundaries that support: - freelancer/owner - future collaborators - client users Even if the initial UI exposes only a limited role set, the underlying authorization model should be extensible. --- SECURITY, PRIVACY, AND AUDITABILITY Treat client, project, communication, and financial information as sensitive business data. Explicitly design for: - secure authentication - authorization on every protected resource - tenant/workspace isolation - least-privilege access - secure session handling - password security - appropriate encryption in transit - secure secret management - input validation - output encoding - protection against common web vulnerabilities - file-upload security - API authorization - rate limiting where appropriate - audit logging for important actions - safe error handling - secure payment integration boundaries - privacy-conscious data handling - data deletion/export considerations - backup/recovery considerations Do not claim formal regulatory compliance unless the requirements and implementation actually establish it. Identify where legal/privacy requirements depend on deployment jurisdiction and should be reviewed by qualified professionals. --- ACCESSIBILITY Design toward WCAG 2.2 AA-level accessibility where practical. Specify: - keyboard navigation - visible focus states - semantic structure - accessible forms - labels and validation messages - sufficient contrast - screen-reader considerations - non-color-only status indicators - accessible dialogs - accessible tables and charts - reduced-motion considerations - responsive text/layout behavior Accessibility must be part of the component architecture rather than an afterthought. --- VISUAL DIRECTION Use a modern SaaS visual language combining: - efficient information architecture - productivity-oriented layouts - polished visual hierarchy - premium but restrained presentation - professional dashboards - clear data visualization - consistent spacing - strong typography - reusable components - purposeful interaction feedback Avoid: - excessive decoration - visual clutter - gimmicky animations - generic template aesthetics - unnecessary gradients - excessive glassmorphism - poor information density - dashboard elements that exist merely for appearance Create a coherent design system covering: - typography - spacing - layout - grid - colors - surfaces - borders - shadows - icons - buttons - forms - tables - cards - navigation - modals - dropdowns - tabs - badges - alerts - toasts - charts - Kanban components - calendar components - responsive behavior - interaction states Include hover, focus, active, disabled, loading, empty, success, warning, error, and destructive states where relevant. --- RESPONSIVE STRATEGY Do not treat mobile as a smaller desktop. Define which workflows are: Desktop-primary Examples: - complex project setup - advanced invoice editing - reports - workload planning - detailed file management - complex Kanban operations Mobile-primary or mobile-optimized Examples: - checking deadlines - starting/stopping timers - updating task status - reading/responding to messages - reviewing notifications - quick project access Explain responsive behavior for important screens. --- TECHNICAL ARCHITECTURE You must recommend a modern, practical technology stack based on the requirements. Do not select technologies merely because they are fashionable. Evaluate the trade-offs of the chosen stack in terms of: - development speed - maintainability - scalability - security - ecosystem maturity - AI-assisted development - hosting/deployment practicality - developer availability - database requirements - authentication - file storage - background jobs - notifications - PDF generation - future integrations Prefer a coherent architecture over a collection of unrelated technologies. Define, as appropriate: - frontend architecture - backend architecture - database - authentication - API architecture - file storage - background jobs - email/notification infrastructure - PDF generation - observability - testing - deployment - environment management - secrets/configuration Where multiple technologies are viable, choose one recommended approach and briefly explain the rationale. Do not present an endless list of alternatives. --- DATA MODEL Create a production-oriented conceptual data model. Define relevant entities such as: - Workspace - User - Membership - Client - ClientUser - Project - Milestone - Task - TimeEntry - Invoice - InvoiceItem - RecurringInvoice - Payment - File - Comment - Conversation - Message - Notification - Reminder - AuditLog Add or remove entities when justified by the actual architecture. For each important entity specify: - purpose - key fields - relationships - ownership - authorization considerations - important indexes/constraints - lifecycle/state considerations Do not over-engineer the schema. --- API AND BACKEND REQUIREMENTS Define the API contract or equivalent server-side interfaces needed to support the application. For important resources specify: - endpoint/action - HTTP method where applicable - authentication requirement - authorization requirement - request structure - validation - response structure - error behavior - pagination/filtering/sorting where applicable - idempotency requirements where relevant Pay particular attention to: - invoice operations - recurring invoices - payment events - file operations - client access - messaging - time tracking - notifications - audit logs Use consistent API conventions. --- VALIDATION AND ERROR HANDLING Specify validation rules for important user inputs. The application must handle: - invalid input - missing required fields - invalid dates - impossible date relationships - duplicate records - unauthorized access - expired sessions - unavailable resources - upload failures - payment integration failures - email failures - background-job failures - network failures - concurrency conflicts where relevant Error messages should be understandable to users without exposing sensitive implementation details. --- INTEGRATION ARCHITECTURE Implement only essential integrations initially, while creating clean abstraction boundaries for future services. The architecture should be capable of supporting future integrations involving: - payment providers - accounting systems - calendars - cloud storage - email - automation platforms - other business tools Do not build unnecessary integrations simply to make the specification look comprehensive. --- SEARCH, FILTERING, AND PRODUCTIVITY Where appropriate, provide efficient: - search - filtering - sorting - status filtering - date filtering - client/project filtering - invoice filtering - task filtering Prioritize common workflows over exhaustive filtering everywhere. --- PERFORMANCE Define practical performance expectations for: - dashboard loading - project views - Kanban interactions - calendar views - invoice lists - messaging - file operations - mobile usage Use pagination, lazy loading, caching, background processing, and other mechanisms where justified. Do not optimize prematurely. --- TWO-PHASE WORKFLOW The work must happen in two explicit phases. PHASE 1 — SPECIFICATION AND VALIDATION Before implementation, produce a complete product and technical specification covering: 1. product overview 2. user roles 3. information architecture 4. user journeys 5. screen inventory 6. navigation 7. UX flows 8. functional requirements 9. design system 10. responsive behavior 11. data model 12. authorization model 13. API architecture 14. validation rules 15. error states 16. integrations 17. security/privacy 18. accessibility 19. performance considerations 20. testing strategy 21. deployment architecture 22. acceptance criteria 23. implementation plan 24. unresolved assumptions or risks Then internally validate the specification for: - contradictions - missing dependencies - impossible workflows - inconsistent permissions - duplicated data - security gaps - accessibility gaps - mobile inconsistencies - API/data-model mismatches - unclear acceptance criteria Resolve issues before moving to Phase 2. If a genuinely critical product decision cannot be determined from the requirements, explicitly identify it rather than silently inventing a business rule. PHASE 2 — IMPLEMENTATION Use the validated Phase 1 specification as the authoritative implementation blueprint. Implement the application according to that specification. Do not casually redesign core architecture during implementation. If implementation reveals a genuine technical conflict, identify the conflict, choose the smallest sound architectural adjustment, and keep the specification and implementation synchronized. Build reusable components and maintainable modules rather than duplicating logic. --- SCREEN AND UX SPECIFICATION For every major screen, specify: - purpose - primary user - entry points - navigation - layout - major components - primary actions - secondary actions - information hierarchy - states - permissions - responsive behavior - accessibility considerations - relevant API/data dependencies At minimum consider: - login - registration - verification - password reset - dashboard - clients - client detail - projects - project detail - milestone management - task list - Kanban - task detail - calendar - workload - time tracking - invoices - invoice creation/editing - invoice detail - recurring invoices - reports - files - client messaging - notifications - settings - profile/account - client portal - client project view - client invoices - client files - client communication Add screens when required by the architecture. --- USER JOURNEYS Define the critical end-to-end workflows, including: New freelancer setup Account → workspace → client → project → milestone → tasks Project execution Project → milestone → task → time tracking → completion Client collaboration Client portal → project → files/messages/comments → freelancer response Invoice workflow Project/time → invoice → send → reminder → payment status Recurring billing Recurring invoice definition → scheduled generation → invoice → reminder → payment record Deadline management Task/milestone → calendar → reminder → completion/overdue handling Identify failure and recovery states for these workflows. --- ACCEPTANCE CRITERIA Create testable acceptance criteria for major functionality. Criteria should describe observable behavior rather than vague quality claims. Examples of the type of specificity required: - A freelancer can create a project and associate it with an existing client. - A project can contain milestones. - A milestone can contain tasks and a target date. - A time entry can be classified as billable or non-billable. - Invoice totals correctly account for applicable line items, discounts, and taxes according to the defined calculation rules. - A client cannot access another client's project data. - Private freelancer comments cannot appear in the client portal. - Unauthorized API requests are rejected. - Important invoice/payment actions produce appropriate audit records. Create the complete criteria yourself based on the final architecture. --- TESTING STRATEGY Define appropriate: - unit tests - integration tests - API tests - authorization tests - end-to-end tests - responsive tests - accessibility tests - critical financial calculation tests - file/security tests - payment-event tests - regression tests Prioritize testing around high-risk business logic and security boundaries. --- FUTURE EXTENSIBILITY Architect V1 so future features can be added without destabilizing the core system. Potential future capabilities may include: - additional team members - advanced CRM - proposals - contracts - expenses - accounting integrations - broader payment functionality - automation - advanced analytics Do not implement these merely because they are possible. Instead, identify architectural boundaries that make them feasible later. --- IMPORTANT CONSTRAINTS Do not: - invent unprovided business policies as facts - claim formal legal/regulatory compliance without evidence - expose private client/workspace data - hard-code the architecture unnecessarily to one future provider - add features solely to increase perceived sophistication - create artificial complexity - sacrifice usability for technical novelty - treat mobile as a scaled-down desktop - mix private freelancer communication with client-visible communication - treat operational reporting as formal accounting - store unnecessary sensitive payment information - hide critical assumptions - leave important permission boundaries undefined When a decision is genuinely unspecified but has low impact, make the most sensible professional choice. When a decision is high-impact and cannot responsibly be inferred, explicitly flag it. --- OUTPUT REQUIREMENTS Phase 1 Deliverable Produce a structured Product + Technical Specification containing: 1. Executive product definition 2. Product goals and non-goals 3. User roles and permissions 4. Information architecture 5. Feature architecture 6. User journeys 7. Complete screen inventory 8. Detailed screen specifications 9. Design system 10. Responsive strategy 11. Data model 12. API architecture 13. Authentication/authorization 14. Security/privacy architecture 15. Accessibility requirements 16. Integration architecture 17. Notification/reminder architecture 18. Validation/error strategy 19. Performance strategy 20. Testing strategy 21. Deployment architecture 22. Acceptance criteria 23. Implementation roadmap 24. Assumptions, risks, and unresolved decisions Use tables where they improve clarity. Do not bury important requirements inside long prose. Phase 2 Deliverable Implement the application using the validated specification. The implementation must include: - reusable components - consistent styling - functional navigation - realistic application states - appropriate responsive behavior - authentication architecture - authorization boundaries - persistent data architecture - core freelancer workflows - client portal workflows - project/milestone/task management - Kanban - calendar - advanced time tracking - professional invoicing - recurring invoice architecture - file management - messaging/comments - notifications/reminders - reporting - security protections - accessibility considerations - appropriate tests If the environment prevents implementation of a particular infrastructure dependency, create a clean abstraction/mock boundary rather than pretending the dependency is fully operational. --- QUALITY BAR Do not consider the work complete merely because the screens look polished. The finished result must be: - functionally coherent - technically implementable - internally consistent - secure by design - accessible - responsive - maintainable - extensible - realistic for a modern SaaS product - appropriate for growing freelancers - useful for both freelancer and client workflows - explicit about important assumptions - testable through concrete acceptance criteria The UI should feel like a credible modern SaaS product that a professional freelancer could realistically use every day. --- SELF-CHECK Before delivering each phase, silently verify: 1. Does the product clearly solve the stated freelancer-management problem? 2. Are freelancers and clients given the correct capabilities? 3. Are private and client-visible data properly separated? 4. Are projects correctly connected to milestones and tasks? 5. Are deadlines represented consistently across tasks, milestones, calendar, reminders, and dashboard? 6. Does time tracking correctly distinguish billable and non-billable work? 7. Are invoice calculations and lifecycle states clearly defined? 8. Are recurring invoices modeled separately from generated invoices? 9. Is payment integration provider-independent where appropriate? 10. Are authentication and authorization distinct and correctly designed? 11. Is the architecture ready for future collaborators? 12. Are files securely permissioned? 13. Are comments and client messaging appropriately separated? 14. Are important financial and security actions auditable? 15. Are mobile workflows intentionally designed rather than merely compressed? 16. Are accessibility requirements represented throughout the UI architecture? 17. Are API, database, and frontend requirements mutually consistent? 18. Are failure, loading, empty, overdue, and permission-denied states covered? 19. Have unsupported claims and invented facts been avoided? 20. Can another capable developer or coding AI understand and implement the specification without knowing this conversation? Fix meaningful problems before presenting the deliverable. --- COMPLETION CONDITION Phase 1 is complete only when the specification is internally coherent, sufficiently detailed for implementation, and validated against the requirements above. Phase 2 is complete only when the application implementation faithfully follows the validated specification and the critical user journeys, security boundaries, responsive behavior, and acceptance criteria have been addressed. Do not declare success based solely on visual polish. Deliver a production-grade freelancer workspace whose validated specification can serve as the authoritative blueprint for implementation, followed by an implementation that faithfully executes that blueprint.
GPT

Universal Engineering System

Add to Cart
PromptBase Select
Get this prompt + 9 more with Select$14 your first month, then $19/mo$14 first month, then $19/mo
View Select
Instant accessInstant access
Usage rightsCommercial use
Money-back guaranteeMoney‑back
By purchasing this prompt, you agree to our terms of service
GPT-5.6
Tested icon
Guide icon
4 examples icon
Free credits icon
Turn any idea into a deeply structured, high-quality AI prompt through intelligent gap analysis, adaptive questioning, expert refinement, edge-case detection, and final self-review. Designed for beginners and advanced users, it adapts to the complexity of each task and helps transform incomplete ideas into clear, reusable prompts for writing, business, research, coding, marketing, education, and more.
...more
Added over 1 month ago
Report
Browse Marketplace