Your message has been sent.
We’ll process your request and contact you back as soon as possible.
The form has been successfully submitted.
Please find further information in your mailbox.
If you’re here, you’ve probably hit a wall: your in-house team’s maxed out, you’re dealing with unfamiliar tech, or a past outsourcing experience didn’t go so great. Whatever brought you here, choosing a software development partner you can count on is worth getting right.
And you’re far from alone. According to Grand View Research, the global IT services outsourcing market is estimated to reach $860 billion in 2026, up from $797.4 billion in 2025. That’s a lot of businesses turning to outside expertise. But a bigger market also means more companies to choose from, and not all of them will be right for your project.

So, how do you tell a solid engineering team from one that looks great on paper but struggles once development starts?
In this guide, I’ll walk you through how to choose a software development partner, what to ask before signing a contract, and which warning signs should make you think twice. We’ll also cover engagement models, pricing, and a few things that have become especially relevant in 2026, including the use of AI in software development.
At Innowise, we’ve worked with everyone from scrappy startups to global enterprises and everything in between. And here’s the hard truth: the smartest companies don’t wait for a crisis to bring in external help, they do it when they want to move faster, minimize risk, or take on something too big to handle alone. It’s not about just filling seats. It’s about making sure your tech strategy doesn’t stall when the stakes are high.
Let me break down some of the most common (and critical) moments when it pays to hire software development companies.
Even top-tier in-house teams can hit a wall, especially when you’re diving into unfamiliar territory like AI, blockchain, or heavy compliance work. If that sounds like your team, don’t wait until things spiral. We’ve seen companies try to master advanced machine learning mid-project, only to burn months and completely miss their launch window. By teaming up with a partner that’s already built similar solutions, you’ll skip the trial-and-error phase and avoid costly delays.
Also, if your business is growing at breakneck speed, your internal team’s probably already running full throttle. That’s where a solid software development provider steps in, keeping critical projects on schedule without draining your core team’s energy or piling on last-minute hires. Think of it as an expert squad on standby, ready to jump in when things heat up and step back when they cool down.
Your in-house crew might be more valuable when they’re focused on product roadmaps, user research, or building strategic software development partnership — not troubleshooting code or wrestling with server configs. One client of ours, a mid-sized SaaS company, was stuck in a cycle of constant maintenance. Their team was so tied up with everyday dev tasks, that they had zero bandwidth to explore new market opportunities. After outsourcing the heavy lifting of development to our team, they freed up in-house talent to focus on innovation and launched a new product three months earlier than planned.
Honestly, having your top minds fix every little bug is a huge waste of talent. By outsourcing those time-draining tasks, you free your in-house experts to tackle the high-level work that really drives revenue and sharpens your market edge.
Big projects like ERP overhauls or building advanced analytics platforms can quickly overwhelm even strong internal teams. I’ve seen companies jump into legacy upgrades thinking it’s just a UI refresh, only to end up doubling their timelines and blowing their budgets trying to fix unexpected problems like outdated dependencies, missing documentation, and incompatible workflows.
Here’s the thing: you don’t want to realize your infrastructure can’t handle real-time data pipelines after six months of sunk cost. That’s where a seasoned software development partner comes in — someone who’s been through the complexity before, knows where the common traps are, and helps you avoid them before they take your entire roadmap off course.
Some industries just don’t give you room for mistakes. FinTech, healthcare, e-commerce — they all come with strict rules, and slipping up can lead to fines, delays, or serious reputation damage.
If you haven’t dealt with standards like HIPAA, PCI DSS, PSD2 or others before, it’s not something you want to wing. But bringing in a partner who’s already worked in your space means your product is built with compliance in mind from day one, so you can move fast without second-guessing the basics.
When you’re validating an idea, speed is everything. You need to get your MVP in users’ hands fast, not spend months reinventing the wheel. A good software development provider already has the frameworks, tools, and workflows in place to move quickly without cutting corners.
This isn’t about building a throwaway prototype. It’s about launching something lean but legit — just enough to get real feedback, iterate fast, and pivot if needed.
Even top-tier in-house teams can hit a wall, especially when you’re diving into unfamiliar territory like AI, blockchain, or heavy compliance work. If that sounds like your team, don’t wait until things spiral. We’ve seen companies try to master advanced machine learning mid-project, only to burn months and completely miss their launch window. By teaming up with a partner that’s already built similar solutions, you’ll skip the trial-and-error phase and avoid costly delays.
Also, if your business is growing at breakneck speed, your internal team’s probably already running full throttle. That’s where a solid software development provider steps in, keeping critical projects on schedule without draining your core team’s energy or piling on last-minute hires. Think of it as an expert squad on standby, ready to jump in when things heat up and step back when they cool down.
Your in-house crew might be more valuable when they’re focused on product roadmaps, user research, or building strategic software development partnership — not troubleshooting code or wrestling with server configs. One client of ours, a mid-sized SaaS company, was stuck in a cycle of constant maintenance. Their team was so tied up with everyday dev tasks, that they had zero bandwidth to explore new market opportunities. After outsourcing the heavy lifting of development to our team, they freed up in-house talent to focus on innovation and launched a new product three months earlier than planned.
Honestly, having your top minds fix every little bug is a huge waste of talent. By outsourcing those time-draining tasks, you free your in-house experts to tackle the high-level work that really drives revenue and sharpens your market edge.
Big projects like ERP overhauls or building advanced analytics platforms can quickly overwhelm even strong internal teams. I’ve seen companies jump into legacy upgrades thinking it’s just a UI refresh, only to end up doubling their timelines and blowing their budgets trying to fix unexpected problems like outdated dependencies, missing documentation, and incompatible workflows.
Here’s the thing: you don’t want to realize your infrastructure can’t handle real-time data pipelines after six months of sunk cost. That’s where a seasoned software development partner comes in — someone who’s been through the complexity before, knows where the common traps are, and helps you avoid them before they take your entire roadmap off course.
Some industries just don’t give you room for mistakes. FinTech, healthcare, e-commerce — they all come with strict rules, and slipping up can lead to fines, delays, or serious reputation damage.
If you haven’t dealt with standards like HIPAA, PCI DSS, PSD2 or others before, it’s not something you want to wing. But bringing in a partner who’s already worked in your space means your product is built with compliance in mind from day one, so you can move fast without second-guessing the basics.
When you’re validating an idea, speed is everything. You need to get your MVP in users’ hands fast, not spend months reinventing the wheel. A good software development provider already has the frameworks, tools, and workflows in place to move quickly without cutting corners.
This isn’t about building a throwaway prototype. It’s about launching something lean but legit — just enough to get real feedback, iterate fast, and pivot if needed.

You’ll often hear the words vendor and partner used interchangeably. And technically, either can describe an external software company.
The difference is usually in how you work together. A vendor may be hired to complete a defined task, while a development partner tends to take on a broader role in planning, technical decisions, and ongoing product work.
| Criteria | Software vendor | Software development partner |
|---|---|---|
| Main focus | Completing agreed tasks | Supporting product and business goals |
| Involvement | Usually limited to assigned work | Often involved in planning and technical decisions |
| Responsibility | Defined deliverables | A wider set of delivery responsibilities |
| Communication | Task updates and approvals | Regular discussion of progress, risks, and options |
| Problem-solving | Resolves issues within the agreed scope | May suggest changes to the approach when needed |
| Relationship | Often project-specific | May continue across releases and new projects |
Neither approach is automatically better. If you need a small, well-defined integration, a vendor may be exactly what you’re looking for.
But if you’re building a product that will change over time, I’d look for a team willing to understand where the business is going and help you make sound technical decisions along the way.
Finding a software development company is easy enough. Finding one that fits your project, works well with your team, and can deliver what it promises takes more effort.
Here’s the process I’d recommend. It covers the key things worth checking so you know what to look for, what to ask, and where to be cautious.
Before you start comparing software companies, get clear on what you’re trying to build.
You don’t need a hundred-page specification at this stage. But you should know what problem the software will solve, who will use it, and what you expect to achieve.
I’d put together a short project brief covering:
For example, “We need a customer portal” gives a development team very little to work with.
“We need a self-service portal connected to our CRM and billing platform, with the first release planned for Q2” is a much better starting point.
And if you’re unsure about the technical details, that’s fine. A good development partner should help you work through them during discovery.
Not every project needs the same setup. Before speaking with software companies, decide how much control you want to keep and which responsibilities you’d prefer to hand over.
Location matters, too.
I’d compare locations based on working-hour overlap, the availability of engineers with the right skills, the legal environment, and the total cost of collaboration.
For a closer comparison of the options, see our guide to in-house vs outsourcing software development.
Now it’s time to find companies worth talking to.
I’d start with platforms such as Clutch and GoodFirms, then look at referrals, LinkedIn, and companies you’ve met at industry events.
Don’t rely on ratings alone. Reviews can help you identify candidates, but they’re only one part of the picture.
As you research, narrow your search using a few practical filters:
You don’t need to interview twenty companies. I’d recommend creating a shortlist of three to five candidates that meet your main requirements.
Send each company the same request for information (RFI) to learn more about their capabilities, or a request for proposal (RFP) if you’re ready to evaluate specific solutions and costs. Include your business goals, expected scope, technical requirements, timeline, budget range, desired team setup, and evaluation criteria.
Ask them to explain their proposed approach, team composition, assumptions, estimated cost, and main risks.
This makes the proposals much easier to compare. If every company receives a different description of the project, you may end up comparing apples and oranges.
A company may list dozens of programming languages and frameworks on its website. That doesn’t tell you whether the people assigned to your project have enough experience with them.
I’d ask to speak with the proposed technical lead or architect, especially if you’re building a complex system.
Discuss how they’d approach your architecture, handle integrations, and make decisions about performance and maintainability.
I’d also look at their engineering practices. How do they review code? What does their QA process cover? Do they use automated tests? How are deployments managed? Can their DevOps team explain its approach to CI/CD and release management?
Certifications can provide additional evidence of an established process, particularly for cloud infrastructure, quality management, and information security. But I’d still want to see how those processes work on real projects.
Industry knowledge deserves the same attention.
If you’re building financial software, for example, ask about payment integrations, audit trails, and access controls. If you’re developing healthcare software, discuss patient data handling and the relevant regulatory requirements.
A technical interview focused on your own project can tell you a lot more than a generic capability presentation.
Don’t skip due diligence. A well-written portfolio looks good, but you need to know what the company contributed and how the work turned out.
Look for projects that resemble yours in complexity, technology, industry, or delivery model.
For each relevant case study, try to understand the original problem, what the team was responsible for, which difficulties came up, and what the client gained from the finished solution.
Be careful with vague success stories. If a company says it improved performance or reduced costs, ask what was measured and how.
And whenever possible, speak to a past client directly.
I’d ask about the working relationship as much as the finished software. Did the team communicate well? How did it deal with changes? Were there unexpected costs? Would the client hire the same company again?
Those conversations can reveal things you’ll never find in a sales deck.
Even talented developers can struggle when nobody has a clear grip on the project.
That’s why I’d spend time understanding how the company plans work, tracks progress, and manages risks.
Ask who will be responsible for delivery and how you’ll stay informed. Find out which tools the team uses, how often it holds reviews, and how it handles changes to requirements.
At Innowise, we use established delivery practices, regular sprint reviews, and tools such as Jira and Confluence to keep work visible to the people involved.
But the specific tool matters less than how the team uses it.
For instance, if an integration takes longer than expected, will your partner raise the issue early and explain the options? Or will you first hear about it when the deadline has already slipped?
I also recommend asking about a project that didn’t go according to plan. What happened? How did the team respond? What would they do differently now?
A thoughtful answer is a good sign. After all, every experienced development company has likely dealt with its share of challenges.
Technical experience won’t help much if your teams struggle to work together.
Think about how your company operates. Do you prefer quick discussions or detailed written updates? Who makes product decisions? How quickly can stakeholders review and approve work?
Your development partner should be able to adapt to the way your team works.
Time zones matter here, too. A six-hour difference may be manageable if you have several overlapping hours and a clear communication schedule. But it becomes harder when every small decision takes another day.
I’d pay attention to communication during the selection process itself.
Do they answer your questions directly? Are the people you’ll work with involved in the discussions? Do they ask for clarification when something is unclear?
You don’t need identical working cultures. You need a team that communicates well with yours and knows how to resolve misunderstandings before they become expensive.
Your project may look very different six months from now.
Perhaps you’re launching an MVP with three developers today, but you’ll need a larger team once the first customers arrive. Or you may need a security specialist, data engineer, or solution architect for a particular stage of development.
Ask how the company handles changes in team size.
How quickly can it add engineers with the right experience? How does onboarding work? Who transfers project knowledge when someone joins or leaves? Can the team become smaller when the workload decreases?
I’d also ask how the company approaches new technologies and technical improvements.
You want engineers who can explain whether and when a different architecture, framework, or development approach would benefit your product.
But be wary of teams that recommend new technology simply because it’s popular.
Sometimes the best technical decision is to keep what already works, fix a troublesome component, or simplify a complicated workflow.
Security should come up before anyone gets access to your systems, code, or customer data.
Start with the contract. Make sure it clearly covers confidentiality, intellectual property ownership, the use of subcontractors, and what happens to your information when the partnership ends.
Ask about the company’s security practices, including access controls, secure software development, code reviews, vulnerability management, and data handling policies.
Certifications and independent assessments are useful here. Depending on your project, you may want to review evidence related to ISO 27001, ISO 9001 certificates, SOC 2 reports, or evidence of compliance with industry-specific requirements.
For GDPR or HIPAA, ask how the team will support your compliance obligations. Neither certification claims nor previous industry experience should replace a proper assessment of your own system.
At Innowise, our management systems include ISO 9001, ISO 27001, and ISO 13485 certifications. Our security management approach covers access control, data protection, secure development, and security reviews throughout delivery.
I’d recommend reviewing the relevant certificates and security documentation before signing, regardless of which company you choose.
In 2026, I’d include AI practices in every serious vendor assessment.
Development teams may use AI coding assistants for tasks such as writing unit tests, generating documentation, suggesting code, or exploring possible solutions.
That can be useful. But you need to understand what controls are in place.
Ask which tools the engineers use and what they’re allowed to do with them. More specifically, find out whether client code, credentials, or sensitive business information is shared with external AI services and what safeguards are in place.
I’d also want to understand how AI-generated code is reviewed.
Does every change go through the same peer review and testing process as manually written code? How does the team check for security issues, licensing concerns, or incorrect suggestions?
Another question worth asking is whether AI has made a measurable difference to delivery.
If a company claims it can complete projects faster because of AI, ask what that estimate is based on. Has it measured changes in development time, review effort, defects, or overall cost?
You want a team that knows when AI is useful, checks its output carefully, and can explain the trade-offs.
Before committing to a large development contract, consider starting small.
A paid discovery phase gives both sides time to clarify requirements, review the technical environment, examine risks, and agree on the proposed architecture.
You should come away with something useful: a clearer scope, an initial backlog, technical recommendations, and estimates for cost and timeline, along with the assumptions behind them.
If your requirements are already well defined, a trial sprint may be a better way to assess the team, while a proof of concept (PoC) can help test technical feasibility.
Choose a limited piece of work that represents a real challenge in the project, such as integrating an API or building a small but complete feature.
Agree on success criteria before it starts. These might include code quality, acceptance criteria, communication, documentation, and delivery against the agreed scope.
The pilot isn’t about expecting everything to go perfectly. It’s about seeing how the team works and whether you’d feel comfortable trusting it with a larger project.
Our IT consulting services can help with early technical assessments, planning, and solution decisions.
Once you’ve found a few companies you like, you’ll need to compare their commercial offers.
There’s no single pricing model that works for every project. The right choice depends on how clearly you can define the scope, how often you expect requirements to change, and how much control you want over the team.
Here’s how the common models compare.
| Pricing model | How it works | Best for | Risks |
|---|---|---|---|
| Fixed price | You agree on a defined scope, deliverables, timeline, and price before development starts. | Projects with stable requirements and clear acceptance criteria. | Changes may require additional payments or contract updates. |
| Time & materials | You pay for the time spent on the project, usually based on agreed hourly or daily rates. | Products with changing requirements, ongoing development, or uncertain scope. | Final costs can grow without budget reviews and clear priorities. |
| Dedicated team | You pay for an assigned team, commonly through a monthly fee based on its composition and capacity. | Long-term development where you need consistent people working on the product. | You may pay for capacity that isn't fully used if priorities or workloads change. |
Don’t judge an offer by the hourly rate alone.
Suppose one company quotes a lower rate but needs more time for development, requires extensive supervision, and charges separately for testing. Another company’s offer may look more expensive initially but include a broader set of responsibilities.
To compare them fairly, request an itemized estimate covering development, QA, project management, DevOps, infrastructure, licenses, and post-launch support where relevant.
I’d also ask what the estimate excludes, which assumptions it depends on, and how changes will be priced.
And remember: a fixed-price contract doesn’t mean the requirements can change indefinitely without affecting the budget. Likewise, time and materials shouldn’t mean spending money without clear reporting.
The contract should clearly spell out how costs are approved, tracked, and reviewed.
Not every warning sign means you should reject a company immediately. But if several of these come up during the first few conversations, I’d be cautious.
A company agrees to your budget, timeline, and every feature before getting into the details? That's worth questioning. Experienced teams usually want to understand your requirements, technical constraints, and possible risks before making firm commitments.
A low quote can be tempting, especially when you're working with a tight budget. But check what's included. Testing, project management, infrastructure, and post-launch support may come at an extra cost, turning that attractive initial offer into a much bigger bill.
A long list of completed projects doesn't necessarily mean a company can handle yours. Look for work with similar technical requirements, industry challenges, or project complexity. If they can't explain what they delivered and which problems they solved, keep digging.
You've had a great conversation with the sales manager, but what about the engineers who'll build your product? Ask to meet the proposed technical lead and key specialists before signing. You need to know who's doing the work and whether they understand your requirements.
Missed calls, unanswered emails, vague replies. None of these are encouraging during the selection process, when a company should be making its best impression. If getting a straightforward answer takes several follow-ups now, imagine coordinating a complex release later.
Every software project comes with uncertainties, whether it's a tricky integration, changing requirements, or unexpected technical limitations. Be wary of companies that insist everything will go according to plan. You want a team that can identify possible setbacks and explain how it would handle them.
Before signing anything, check who owns the source code, how scope changes affect costs, and what happens if you end the partnership early. Confidentiality, payment terms, and intellectual property rights should be clearly documented. If the wording is vague, get clarification before moving forward.
Ask how the company controls access to sensitive data, protects source code, and responds to security incidents. A team handling confidential information should be able to describe its procedures and provide relevant documentation. General promises about security aren't enough.
Using AI coding assistants isn't a problem in itself. The concern starts when a team can't explain how it reviews and tests AI-generated code or addresses potential licensing issues. You should also know whether your source code or confidential data is shared with external AI services.
What happens if you decide to change development partners or bring the work in-house? You should be able to take your source code, documentation, credentials, and other project assets with you. If the company can't explain how that handover works, you could face an expensive and frustrating transition later.
One more thing: pay attention to how a company reacts when you ask difficult questions.
A good development team should be comfortable discussing limitations, past problems, and contract details. You shouldn’t have to fight for basic information.
Finding the right team is only the beginning. Once development starts, the way you work together has a huge effect on what gets delivered.
I’ve seen well-planned projects run into trouble because decisions took too long or nobody knew who was responsible for an important task.
A few habits can help you avoid that.
Before the first sprint, agree on what success means. That might be a launch date, a performance target, or a measurable improvement in a business process. Keep those goals visible as priorities change.
Decide when you'll meet, where updates will be recorded, and who to contact when something needs attention. Some projects need daily check-ins; others work well with fewer meetings and written updates.
Who approves architecture decisions? Who reviews pull requests? Who signs off on completed features? If you leave these questions unanswered, small delays can turn into bigger problems.
Give external engineers enough context to understand your users and business priorities. Invite them to relevant discussions and make it easy for them to ask questions.
New requirements will come up. What matters is having a process for evaluating their effect on the scope, budget, and timeline before work on those changes starts.
If you're building a product that will need updates and support, think about knowledge transfer, documentation, and maintenance from the beginning. Your future team will appreciate it.
Projects run better when people can flag risks, question assumptions, and admit mistakes early. Problems rarely get cheaper when everyone avoids talking about them.
These habits sound simple, but they require effort from both sides. Your development partner has responsibilities, and so does your internal team.
You can learn a lot about a software company during the first few weeks of working together.
Some teams make collaboration feel natural. Others turn routine decisions into long email threads and constant follow-ups.
Here are seven signs I’d look for.

You shouldn’t have to chase your development team for basic updates.
A good partner makes it clear who’s responsible for communication, when you’ll receive progress reports, and how urgent issues will be handled.
Let’s say a third-party API is causing delays. I’d expect the team to tell you what’s happening, explain the impact, and suggest options while there’s still time to act.
You may still need to adjust the plan. At least you’ll be making that decision with the facts in front of you.
If your team uses Linear, Figma, and Slack, you shouldn’t need to move everything into Jira simply because that’s what the vendor prefers.
Of course, some tools may be necessary for security or technical reasons. But those decisions should be discussed rather than imposed.
A good development partner takes time to understand how your company works and finds a practical way to collaborate.
I appreciate engineers who ask why a feature is needed before deciding how to build it.
For example, suppose you want real-time analytics across your platform. An experienced team should ask how quickly users need the data, what they’ll do with it, and whether the existing infrastructure can support the requirement.
Those questions may lead to a simpler or less expensive solution.
The best technical discussions often begin when someone challenges an assumption for a good reason.
You should know what the team can deliver, what remains uncertain, and where trade-offs may be necessary.
If you add a major feature halfway through development, a good partner will explain what needs to change in the budget, timeline, or original scope.
Be cautious of companies that agree to every request without discussing the consequences.
You know your business and customers. Your development partner brings technical experience.
Both perspectives matter.
You should feel comfortable questioning technical recommendations, and engineers should be able to explain their concerns without the discussion turning into a contest over who’s right.
When both sides listen and take feedback seriously, decisions tend to be easier.
Even good partnerships have disagreements.
A feature may work differently from what stakeholders expected, or a design decision may need to be reconsidered.
What’s important is having a clear way to deal with the problem.
Regular reviews, written decisions, and an agreed escalation process help teams resolve issues before they affect the wider project.
You want engineers who understand the product well enough to contribute to discussions, spot dependencies, and document their work.
That becomes especially valuable as the project grows.
A team that records technical decisions, shares knowledge, and prepares for future maintenance makes the product easier to manage, even when team members come and go.
Before choosing a company, use this checklist during your interviews and proposal reviews.
You don’t need perfect answers to every question, but you should come away with a clear understanding of how the company works.
Before choosing a company, use this checklist during your interviews and proposal reviews.
You don’t need perfect answers to every question, but you should come away with a clear understanding of how the company works.
At Innowise, we’ve spent years helping businesses build software products and improve systems they already depend on.
We work with companies that need extra engineers, dedicated product teams, or support across the full development process.
Here’s what we bring to the table.
With 3,500+ IT professionals, 1,600+ delivered projects, and 19+ years of experience, we’ve worked on everything from customer-facing applications to complex enterprise systems.
Our teams cover software engineering, cloud, data, AI, QA, DevOps, and other areas, so we can put together a team based on the work your project requires.
We believe clients should know what’s happening on their projects without having to chase updates.
Our delivery teams use structured planning, regular reviews, documented decisions, and progress tracking to keep work organized.
That also means discussing risks early and making sure changes are reviewed before they affect the delivery plan.
We want clients to feel comfortable asking questions and raising concerns.
Our teams work closely with your stakeholders to understand priorities, explain technical decisions, and discuss possible issues.
If something needs to change, we’d rather have that conversation early than leave you with an unpleasant surprise near release.
Many software products need continued development after their first launch.
We support clients through new releases, system updates, maintenance, and changing business requirements.
That continuity helps teams build a deeper understanding of the product and reduces the amount of knowledge that needs to be reacquired with every new phase.
We have experience delivering software for businesses across different markets, time zones, and industries.
Our ISO certifications cover quality management, information security, and medical device quality management. We also maintain documented procedures for protecting client information and managing security throughout software delivery.
Whether you need a few experienced engineers or a complete development team, we’re ready to discuss your project, go over your requirements, and help you choose a suitable way of working.




Choosing a software development partner takes more than comparing hourly rates and reading a few reviews.
You need to understand how the company works, who will build your product, and what happens when things don’t go according to plan.
Start with your requirements, narrow your options, and ask questions that matter to your project. Review relevant work, check security practices, and make sure responsibilities are clearly defined.
And if you’re considering a long-term engagement, start with a discovery phase to clarify the requirements or a small pilot to see how the team works before making a bigger commitment.
The right development partner should make your project easier to manage, help you make better technical decisions, and give you confidence in the work being delivered.
That’s a much stronger foundation than a promising sales pitch.












Your message has been sent.
We’ll process your request and contact you back as soon as possible.